2 * NOTE: Do not modify this file by hand.
3 * Content was generated from source .webidl files.
6 /// <reference no-default-lib="true" />
7 /// <reference lib="es2023" />
9 interface Principal extends nsIPrincipal {}
10 interface URI extends nsIURI {}
11 interface WindowProxy extends Window {}
13 type HTMLCollectionOf<T> = any;
14 type IsInstance<T> = (obj: any) => obj is T;
15 type NodeListOf<T> = any;
17 /////////////////////////////
19 /////////////////////////////
21 interface ActivateMenuItemOptions {
29 interface AddEventListenerOptions extends EventListenerOptions {
33 wantUntrusted?: boolean;
36 interface AddonEventInit extends EventInit {
40 interface AddressErrors {
44 dependentLocality?: string;
45 organization?: string;
54 interface AnalyserOptions extends AudioNodeOptions {
58 smoothingTimeConstant?: number;
61 interface AnimationEventInit extends EventInit {
62 animationName?: string;
64 pseudoElement?: string;
67 interface AnimationPlaybackEventInit extends EventInit {
68 currentTime?: number | null;
69 timelineTime?: number | null;
72 interface AnimationPropertyDetails {
74 runningOnCompositor: boolean;
75 values: AnimationPropertyValueDetails[];
79 interface AnimationPropertyValueDetails {
80 composite: CompositeOperation;
86 interface AssignedNodesOptions {
90 interface AttributeNameValue {
95 interface AudioBufferOptions {
97 numberOfChannels?: number;
101 interface AudioBufferSourceOptions {
102 buffer?: AudioBuffer | null;
107 playbackRate?: number;
110 interface AudioConfiguration {
117 interface AudioContextOptions {
121 interface AudioDataCopyToOptions {
122 format?: AudioSampleFormat;
124 frameOffset?: number;
128 interface AudioDataInit {
129 data: ArrayBufferView | ArrayBuffer;
130 format: AudioSampleFormat;
131 numberOfChannels: number;
132 numberOfFrames: number;
135 transfer?: ArrayBuffer[];
138 interface AudioDecoderConfig {
140 description?: ArrayBufferView | ArrayBuffer;
141 numberOfChannels: number;
145 interface AudioDecoderInit {
146 error: WebCodecsErrorCallback;
147 output: AudioDataOutputCallback;
150 interface AudioDecoderSupport {
151 config?: AudioDecoderConfig;
155 interface AudioEncoderConfig {
157 bitrateMode?: BitrateMode;
159 numberOfChannels?: number;
160 opus?: OpusEncoderConfig;
164 interface AudioEncoderInit {
165 error: WebCodecsErrorCallback;
166 output: EncodedAudioChunkOutputCallback;
169 interface AudioEncoderSupport {
170 config?: AudioEncoderConfig;
174 interface AudioNodeOptions {
175 channelCount?: number;
176 channelCountMode?: ChannelCountMode;
177 channelInterpretation?: ChannelInterpretation;
180 interface AudioOutputOptions {
184 interface AudioSinkDebugInfo {
185 audioEnded?: boolean;
186 hasErrored?: boolean;
189 lastGoodPosition?: number;
191 playbackComplete?: boolean;
196 interface AudioSinkWrapperDebugInfo {
197 audioEnded?: boolean;
198 audioSink?: AudioSinkDebugInfo;
203 interface AudioTimestamp {
204 contextTime?: number;
205 performanceTime?: DOMHighResTimeStamp;
208 interface AudioWorkletNodeOptions extends AudioNodeOptions {
209 numberOfInputs?: number;
210 numberOfOutputs?: number;
211 outputChannelCount?: number[];
212 parameterData?: Record<string, number>;
213 processorOptions?: any;
216 interface AuthenticationExtensionsClientInputs {
219 hmacCreateSecret?: boolean;
220 minPinLength?: boolean;
223 interface AuthenticationExtensionsClientInputsJSON {
226 hmacCreateSecret?: boolean;
227 minPinLength?: boolean;
230 interface AuthenticationExtensionsClientOutputs {
232 credProps?: CredentialPropertiesOutput;
233 hmacCreateSecret?: boolean;
236 interface AuthenticatorSelectionCriteria {
237 authenticatorAttachment?: string;
238 requireResidentKey?: boolean;
239 residentKey?: string;
240 userVerification?: string;
243 interface AutocompleteInfo {
244 addressType?: string;
245 canAutomaticallyPersist?: boolean;
246 contactType?: string;
247 credentialType?: string;
252 interface AvcEncoderConfig {
253 format?: AvcBitstreamFormat;
256 interface Base64URLDecodeOptions {
257 padding: Base64URLDecodePadding;
260 interface Base64URLEncodeOptions {
264 interface BiquadFilterOptions extends AudioNodeOptions {
269 type?: BiquadFilterType;
272 interface BlobEventInit extends EventInit {
276 interface BlobPropertyBag {
277 endings?: EndingType;
281 interface BlockParsingOptions {
282 blockScriptCreated?: boolean;
285 interface BoxQuadOptions {
287 createFramesForSuppressedWhitespace?: boolean;
288 relativeTo?: GeometryNode;
291 interface BufferRange {
296 interface CDMInformation {
297 capabilities: string;
299 isHDCP22Compatible: boolean;
300 keySystemName: string;
303 interface CSSCustomPropertyRegisteredEventInit extends EventInit {
304 propertyDefinition: InspectorCSSPropertyDefinition;
307 interface CSSStyleSheetInit {
310 media?: MediaList | string;
313 interface CacheQueryOptions {
314 ignoreMethod?: boolean;
315 ignoreSearch?: boolean;
316 ignoreVary?: boolean;
319 interface CanvasRenderingContext2DSettings {
321 colorSpace?: PredefinedColorSpace;
322 desynchronized?: boolean;
323 willReadFrequently?: boolean;
326 interface CaretStateChangedEventInit extends EventInit {
327 boundingClientRect?: DOMRectReadOnly | null;
328 caretVisible?: boolean;
329 caretVisuallyVisible?: boolean;
333 reason?: CaretChangedReason;
334 selectedTextContent?: string;
335 selectionEditable?: boolean;
336 selectionVisible?: boolean;
339 interface ChannelMergerOptions extends AudioNodeOptions {
340 numberOfInputs?: number;
343 interface ChannelSplitterOptions extends AudioNodeOptions {
344 numberOfOutputs?: number;
347 interface CheckVisibilityOptions {
348 checkOpacity?: boolean;
349 checkVisibilityCSS?: boolean;
350 contentVisibilityAuto?: boolean;
352 opacityProperty?: boolean;
353 visibilityProperty?: boolean;
356 interface CheckerboardReport {
358 reason?: CheckerboardReason;
360 timestamp?: DOMTimeStamp;
363 interface ChildProcInfoDictionary {
365 cpuCycleCount?: number;
370 threads?: ThreadInfoDictionary[];
371 type?: WebIDLProcType;
372 utilityActors?: UtilityActorsDictionary[];
373 windows?: WindowInfoDictionary[];
376 interface ChromeFilePropertyBag extends FilePropertyBag {
377 existenceCheck?: boolean;
381 interface ClientRectsAndTexts {
382 rectList: DOMRectList;
386 interface ClipboardEventInit extends EventInit {
391 interface ClipboardItemOptions {
392 presentationStyle?: PresentationStyle;
395 interface CloseEventInit extends EventInit {
401 interface CollectedData {
403 id?: Record<string, CollectedFormDataValue>;
407 xpath?: Record<string, CollectedFormDataValue>;
410 interface CompileScriptOptionsDictionary {
412 hasReturnValue?: boolean;
413 lazilyParse?: boolean;
416 interface CompositionEventInit extends UIEventInit {
420 interface ComputedEffectTiming extends EffectTiming {
421 activeDuration?: number;
422 currentIteration?: number | null;
424 localTime?: number | null;
425 progress?: number | null;
428 interface ConsoleInstanceOptions {
430 dump?: ConsoleInstanceDumpCallback;
432 maxLogLevel?: ConsoleLogLevel;
433 maxLogLevelPref?: string;
437 interface ConstantSourceOptions {
441 interface ConstrainBooleanParameters {
446 interface ConstrainDOMStringParameters {
447 exact?: string | string[];
448 ideal?: string | string[];
451 interface ConstrainDoubleRange {
458 interface ConstrainLongRange {
465 interface ContentVisibilityAutoStateChangeEventInit extends EventInit {
469 interface ConvertCoordinateOptions {
470 fromBox?: CSSBoxType;
474 interface ConvolverOptions extends AudioNodeOptions {
475 buffer?: AudioBuffer | null;
476 disableNormalization?: boolean;
479 interface CopyOptions {
480 noOverwrite?: boolean;
484 interface CredentialCreationOptions {
485 identity?: IdentityCredentialInit;
486 publicKey?: PublicKeyCredentialCreationOptions;
487 signal?: AbortSignal;
490 interface CredentialPropertiesOutput {
494 interface CredentialRequestOptions {
495 identity?: IdentityCredentialRequestOptions;
496 mediation?: CredentialMediationRequirement;
497 publicKey?: PublicKeyCredentialRequestOptions;
498 signal?: AbortSignal;
501 interface CustomEventInit extends EventInit {
505 interface DOMMatrix2DInit {
520 interface DOMMatrixInit extends DOMMatrix2DInit {
534 interface DOMPointInit {
541 interface DOMQuadInit {
548 interface DOMRectInit {
555 interface DateTimeValue {
563 interface DecodedStreamDataDebugInfo {
564 audioFramesWritten?: number;
565 haveSentFinishAudio?: boolean;
566 haveSentFinishVideo?: boolean;
568 lastVideoEndTime?: number;
569 lastVideoStartTime?: number;
570 nextAudioTime?: number;
571 streamAudioWritten?: number;
572 streamVideoWritten?: number;
575 interface DecodedStreamDebugInfo {
576 audioQueueFinished?: boolean;
577 audioQueueSize?: number;
578 data?: DecodedStreamDataDebugInfo;
581 lastOutputTime?: number;
586 interface DelayOptions extends AudioNodeOptions {
588 maxDelayTime?: number;
591 interface DeviceAccelerationInit {
597 interface DeviceLightEventInit extends EventInit {
601 interface DeviceMotionEventInit extends EventInit {
602 acceleration?: DeviceAccelerationInit;
603 accelerationIncludingGravity?: DeviceAccelerationInit;
604 interval?: number | null;
605 rotationRate?: DeviceRotationRateInit;
608 interface DeviceOrientationEventInit extends EventInit {
610 alpha?: number | null;
611 beta?: number | null;
612 gamma?: number | null;
615 interface DeviceRotationRateInit {
616 alpha?: number | null;
617 beta?: number | null;
618 gamma?: number | null;
621 interface DictWithAllowSharedBufferSource {
622 allowSharedArrayBuffer?: ArrayBuffer;
623 allowSharedArrayBufferView?: ArrayBufferView;
624 arrayBuffer?: ArrayBuffer;
625 arrayBufferView?: ArrayBufferView;
628 interface DisplayMediaStreamConstraints {
629 audio?: boolean | MediaTrackConstraints;
630 video?: boolean | MediaTrackConstraints;
633 interface DisplayNameOptions {
640 interface DisplayNameResult {
648 interface DocumentTimelineOptions {
649 originTime?: DOMHighResTimeStamp;
652 interface DragEventInit extends MouseEventInit {
653 dataTransfer?: DataTransfer | null;
656 interface DynamicsCompressorOptions extends AudioNodeOptions {
664 interface EMEDebugInfo {
666 sessionsInfo?: string;
669 interface EffectTiming {
671 direction?: PlaybackDirection;
672 duration?: number | string;
676 iterationStart?: number;
680 interface ElementCreationOptions {
685 interface ElementDefinitionOptions {
689 interface EncodedAudioChunkInit {
690 data: ArrayBufferView | ArrayBuffer;
693 transfer?: ArrayBuffer[];
694 type: EncodedAudioChunkType;
697 interface EncodedAudioChunkMetadata {
698 decoderConfig?: AudioDecoderConfig;
701 interface EncodedVideoChunkInit {
702 data: ArrayBufferView | ArrayBuffer;
705 type: EncodedVideoChunkType;
708 interface EncodedVideoChunkMetadata {
709 decoderConfig?: VideoDecoderConfig;
710 svc?: SvcOutputMetadata;
713 interface ErrorEventInit extends EventInit {
721 interface EventInit {
723 cancelable?: boolean;
727 interface EventListenerOptions {
729 mozSystemGroup?: boolean;
732 interface EventModifierInit extends UIEventInit {
736 modifierAltGraph?: boolean;
737 modifierCapsLock?: boolean;
738 modifierFn?: boolean;
739 modifierFnLock?: boolean;
740 modifierNumLock?: boolean;
741 modifierOS?: boolean;
742 modifierScrollLock?: boolean;
743 modifierSymbol?: boolean;
744 modifierSymbolLock?: boolean;
748 interface EventSourceInit {
749 withCredentials?: boolean;
752 interface ExecuteInGlobalOptions {
753 reportExceptions?: boolean;
756 interface FailedCertSecurityInfo {
757 certChainStrings?: string[];
758 certValidityRangeNotAfter?: DOMTimeStamp;
759 certValidityRangeNotBefore?: DOMTimeStamp;
760 errorCodeString?: string;
761 errorMessage?: string;
764 issuerCommonName?: string;
765 overridableErrorCategory?: OverridableErrorCategory;
766 validNotAfter?: DOMTimeStamp;
767 validNotBefore?: DOMTimeStamp;
771 creationTime?: number;
772 lastAccessed?: number;
773 lastModified?: number;
775 permissions?: number;
780 interface FilePropertyBag extends BlobPropertyBag {
781 lastModified?: number;
784 interface FileSourceOptions {
785 addResourceOptions?: FluentBundleAddResourceOptions;
788 interface FileSystemCreateWritableOptions {
789 keepExistingData?: boolean;
792 interface FileSystemFlags {
797 interface FileSystemGetDirectoryOptions {
801 interface FileSystemGetFileOptions {
805 interface FileSystemRemoveOptions {
809 interface FluentBundleAddResourceOptions {
810 allowOverrides?: boolean;
813 interface FluentBundleIteratorResult {
815 value: FluentBundle | null;
818 interface FluentBundleOptions {
819 pseudoStrategy?: string;
820 useIsolating?: boolean;
823 interface FluentMessage {
824 attributes: Record<string, FluentPattern>;
825 value?: FluentPattern | null;
828 interface FluentTextElementItem {
834 interface FocusEventInit extends UIEventInit {
835 relatedTarget?: EventTarget | null;
838 interface FocusOptions {
839 focusVisible?: boolean;
840 preventScroll?: boolean;
843 interface FontFaceDescriptors {
844 ascentOverride?: string;
845 descentOverride?: string;
847 featureSettings?: string;
848 lineGapOverride?: string;
852 unicodeRange?: string;
854 variationSettings?: string;
858 interface FontFaceSetIteratorResult {
863 interface FontFaceSetLoadEventInit extends EventInit {
864 fontfaces?: FontFace[];
867 interface FormAutofillConfidences {
872 interface FormDataEventInit extends EventInit {
876 interface FrameCrashedEventInit extends EventInit {
877 browsingContextId?: number;
879 isTopFrame?: boolean;
882 interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase {
883 entries: GPUBindGroupEntry[];
884 layout: GPUBindGroupLayout;
887 interface GPUBindGroupEntry {
889 resource: GPUBindingResource;
892 interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase {
893 entries: GPUBindGroupLayoutEntry[];
896 interface GPUBindGroupLayoutEntry {
898 buffer?: GPUBufferBindingLayout;
899 sampler?: GPUSamplerBindingLayout;
900 storageTexture?: GPUStorageTextureBindingLayout;
901 texture?: GPUTextureBindingLayout;
902 visibility: GPUShaderStageFlags;
905 interface GPUBlendComponent {
906 dstFactor?: GPUBlendFactor;
907 operation?: GPUBlendOperation;
908 srcFactor?: GPUBlendFactor;
911 interface GPUBlendState {
912 alpha: GPUBlendComponent;
913 color: GPUBlendComponent;
916 interface GPUBufferBinding {
922 interface GPUBufferBindingLayout {
923 hasDynamicOffset?: boolean;
924 minBindingSize?: GPUSize64;
925 type?: GPUBufferBindingType;
928 interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
929 mappedAtCreation?: boolean;
931 usage: GPUBufferUsageFlags;
934 interface GPUCanvasConfiguration {
935 alphaMode?: GPUCanvasAlphaMode;
937 format: GPUTextureFormat;
938 usage?: GPUTextureUsageFlags;
939 viewFormats?: GPUTextureFormat[];
942 interface GPUColorDict {
949 interface GPUColorTargetState {
950 blend?: GPUBlendState;
951 format: GPUTextureFormat;
952 writeMask?: GPUColorWriteFlags;
955 interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase {
958 interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {
961 interface GPUComputePassDescriptor extends GPUObjectDescriptorBase {
964 interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
965 compute: GPUProgrammableStage;
968 interface GPUDepthStencilState {
969 depthBias?: GPUDepthBias;
970 depthBiasClamp?: number;
971 depthBiasSlopeScale?: number;
972 depthCompare?: GPUCompareFunction;
973 depthWriteEnabled?: boolean;
974 format: GPUTextureFormat;
975 stencilBack?: GPUStencilFaceState;
976 stencilFront?: GPUStencilFaceState;
977 stencilReadMask?: GPUStencilValue;
978 stencilWriteMask?: GPUStencilValue;
981 interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
982 defaultQueue?: GPUQueueDescriptor;
983 requiredFeatures?: GPUFeatureName[];
984 requiredLimits?: Record<string, GPUSize64>;
987 interface GPUExtent3DDict {
988 depthOrArrayLayers?: GPUIntegerCoordinate;
989 height?: GPUIntegerCoordinate;
990 width: GPUIntegerCoordinate;
993 interface GPUFragmentState extends GPUProgrammableStage {
994 targets: GPUColorTargetState[];
997 interface GPUImageCopyBuffer extends GPUImageDataLayout {
1001 interface GPUImageCopyExternalImage {
1003 origin?: GPUOrigin2D;
1004 source: ImageBitmap | HTMLCanvasElement | OffscreenCanvas;
1007 interface GPUImageCopyTexture {
1008 aspect?: GPUTextureAspect;
1009 mipLevel?: GPUIntegerCoordinate;
1010 origin?: GPUOrigin3D;
1011 texture: GPUTexture;
1014 interface GPUImageCopyTextureTagged extends GPUImageCopyTexture {
1015 premultipliedAlpha?: boolean;
1018 interface GPUImageDataLayout {
1019 bytesPerRow?: GPUSize32;
1021 rowsPerImage?: GPUSize32;
1024 interface GPUMultisampleState {
1025 alphaToCoverageEnabled?: boolean;
1027 mask?: GPUSampleMask;
1030 interface GPUObjectDescriptorBase {
1034 interface GPUOrigin2DDict {
1035 x?: GPUIntegerCoordinate;
1036 y?: GPUIntegerCoordinate;
1039 interface GPUOrigin3DDict {
1040 x?: GPUIntegerCoordinate;
1041 y?: GPUIntegerCoordinate;
1042 z?: GPUIntegerCoordinate;
1045 interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
1046 layout: GPUPipelineLayout | GPUAutoLayoutMode;
1049 interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
1050 bindGroupLayouts: GPUBindGroupLayout[];
1053 interface GPUPrimitiveState {
1054 cullMode?: GPUCullMode;
1055 frontFace?: GPUFrontFace;
1056 stripIndexFormat?: GPUIndexFormat;
1057 topology?: GPUPrimitiveTopology;
1058 unclippedDepth?: boolean;
1061 interface GPUProgrammableStage {
1062 constants?: Record<string, GPUPipelineConstantValue>;
1063 entryPoint?: string;
1064 module: GPUShaderModule;
1067 interface GPUQueueDescriptor extends GPUObjectDescriptorBase {
1070 interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase {
1073 interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout {
1074 depthReadOnly?: boolean;
1075 stencilReadOnly?: boolean;
1078 interface GPURenderPassColorAttachment {
1079 clearValue?: GPUColor;
1081 resolveTarget?: GPUTextureView;
1082 storeOp: GPUStoreOp;
1083 view: GPUTextureView;
1086 interface GPURenderPassDepthStencilAttachment {
1087 depthClearValue?: number;
1088 depthLoadOp?: GPULoadOp;
1089 depthReadOnly?: boolean;
1090 depthStoreOp?: GPUStoreOp;
1091 stencilClearValue?: GPUStencilValue;
1092 stencilLoadOp?: GPULoadOp;
1093 stencilReadOnly?: boolean;
1094 stencilStoreOp?: GPUStoreOp;
1095 view: GPUTextureView;
1098 interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
1099 colorAttachments: GPURenderPassColorAttachment[];
1100 depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
1101 occlusionQuerySet?: GPUQuerySet;
1104 interface GPURenderPassLayout extends GPUObjectDescriptorBase {
1105 colorFormats: GPUTextureFormat[];
1106 depthStencilFormat?: GPUTextureFormat;
1107 sampleCount?: GPUSize32;
1110 interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
1111 depthStencil?: GPUDepthStencilState;
1112 fragment?: GPUFragmentState;
1113 multisample?: GPUMultisampleState;
1114 primitive?: GPUPrimitiveState;
1115 vertex: GPUVertexState;
1118 interface GPURequestAdapterOptions {
1119 forceFallbackAdapter?: boolean;
1120 powerPreference?: GPUPowerPreference;
1123 interface GPUSamplerBindingLayout {
1124 type?: GPUSamplerBindingType;
1127 interface GPUSamplerDescriptor extends GPUObjectDescriptorBase {
1128 addressModeU?: GPUAddressMode;
1129 addressModeV?: GPUAddressMode;
1130 addressModeW?: GPUAddressMode;
1131 compare?: GPUCompareFunction;
1132 lodMaxClamp?: number;
1133 lodMinClamp?: number;
1134 magFilter?: GPUFilterMode;
1135 maxAnisotropy?: number;
1136 minFilter?: GPUFilterMode;
1137 mipmapFilter?: GPUMipmapFilterMode;
1140 interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
1145 interface GPUStencilFaceState {
1146 compare?: GPUCompareFunction;
1147 depthFailOp?: GPUStencilOperation;
1148 failOp?: GPUStencilOperation;
1149 passOp?: GPUStencilOperation;
1152 interface GPUStorageTextureBindingLayout {
1153 access?: GPUStorageTextureAccess;
1154 format: GPUTextureFormat;
1155 viewDimension?: GPUTextureViewDimension;
1158 interface GPUTextureBindingLayout {
1159 multisampled?: boolean;
1160 sampleType?: GPUTextureSampleType;
1161 viewDimension?: GPUTextureViewDimension;
1164 interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
1165 dimension?: GPUTextureDimension;
1166 format: GPUTextureFormat;
1167 mipLevelCount?: GPUIntegerCoordinate;
1168 sampleCount?: GPUSize32;
1170 usage: GPUTextureUsageFlags;
1171 viewFormats?: GPUTextureFormat[];
1174 interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase {
1175 arrayLayerCount?: GPUIntegerCoordinate;
1176 aspect?: GPUTextureAspect;
1177 baseArrayLayer?: GPUIntegerCoordinate;
1178 baseMipLevel?: GPUIntegerCoordinate;
1179 dimension?: GPUTextureViewDimension;
1180 format?: GPUTextureFormat;
1181 mipLevelCount?: GPUIntegerCoordinate;
1184 interface GPUUncapturedErrorEventInit extends EventInit {
1188 interface GPUVertexAttribute {
1189 format: GPUVertexFormat;
1191 shaderLocation: GPUIndex32;
1194 interface GPUVertexBufferLayout {
1195 arrayStride: GPUSize64;
1196 attributes: GPUVertexAttribute[];
1197 stepMode?: GPUVertexStepMode;
1200 interface GPUVertexState extends GPUProgrammableStage {
1201 buffers?: (GPUVertexBufferLayout | null)[];
1204 interface GainOptions extends AudioNodeOptions {
1208 interface GamepadAxisMoveEventInit extends GamepadEventInit {
1213 interface GamepadButtonEventInit extends GamepadEventInit {
1217 interface GamepadEventInit extends EventInit {
1218 gamepad?: Gamepad | null;
1221 interface GamepadLightColor {
1227 interface GetAnimationsOptions {
1231 interface GetChildrenOptions {
1232 ignoreAbsent?: boolean;
1235 interface GetHTMLOptions {
1236 serializableShadowRoots?: boolean;
1237 shadowRoots?: ShadowRoot[];
1240 interface GetNotificationOptions {
1244 interface GetRootNodeOptions {
1248 interface GleanDistributionData {
1251 values: Record<string, number>;
1254 interface GleanEventRecord {
1256 extra?: Record<string, string>;
1261 interface GleanRateData {
1262 denominator: number;
1266 interface HTMLMediaElementDebugInfo {
1267 EMEInfo?: EMEDebugInfo;
1268 compositorDroppedFrames?: number;
1269 decoder?: MediaDecoderDebugInfo;
1272 interface HashChangeEventInit extends EventInit {
1277 interface HeapSnapshotBoundaries {
1283 interface IDBDatabaseInfo {
1288 interface IDBIndexParameters {
1289 locale?: string | null;
1290 multiEntry?: boolean;
1294 interface IDBObjectStoreParameters {
1295 autoIncrement?: boolean;
1296 keyPath?: string | string[] | null;
1299 interface IDBOpenDBOptions {
1303 interface IDBTransactionOptions {
1304 durability?: IDBTransactionDurability;
1307 interface IDBVersionChangeEventInit extends EventInit {
1308 newVersion?: number | null;
1309 oldVersion?: number;
1312 interface IIRFilterOptions extends AudioNodeOptions {
1314 feedforward: number[];
1317 interface IdentityCredentialInit {
1318 effectiveOrigins?: string[];
1319 effectiveQueryURL?: string;
1322 uiHint?: IdentityCredentialUserData;
1325 interface IdentityCredentialRequestOptions {
1326 providers?: IdentityProviderConfig[];
1329 interface IdentityCredentialUserData {
1330 expiresAfter?: number;
1335 interface IdentityProviderConfig {
1339 effectiveQueryURL?: string;
1340 loginTarget?: string;
1346 interface IdleRequestOptions {
1350 interface ImageBitmapOptions {
1351 colorSpaceConversion?: ColorSpaceConversion;
1352 imageOrientation?: ImageOrientation;
1353 premultiplyAlpha?: PremultiplyAlpha;
1354 resizeHeight?: number;
1355 resizeWidth?: number;
1358 interface ImageCaptureErrorEventInit extends EventInit {
1359 imageCaptureError?: ImageCaptureError | null;
1362 interface ImageEncodeOptions {
1367 interface ImageText {
1373 interface ImportESModuleOptionsDictionary {
1374 global?: ImportESModuleTargetGlobal;
1377 interface InputEventInit extends UIEventInit {
1378 data?: string | null;
1379 dataTransfer?: DataTransfer | null;
1381 isComposing?: boolean;
1382 targetRanges?: StaticRange[];
1385 interface InspectorCSSPropertyDefinition {
1388 initialValue: string | null;
1393 interface InspectorCSSToken {
1394 number?: number | null;
1397 unit: string | null;
1398 value: string | null;
1401 interface InspectorColorToResult {
1404 components: number[] | Float32Array;
1407 interface InspectorFontFeature {
1408 languageSystem: string;
1413 interface InspectorRGBATuple {
1420 interface InspectorStyleSheetRuleCountAndAtRulesResult {
1425 interface InspectorVariationAxis {
1426 defaultValue: number;
1433 interface InspectorVariationInstance {
1435 values: InspectorVariationValue[];
1438 interface InspectorVariationValue {
1443 interface InstallTriggerData {
1444 Hash?: string | null;
1445 IconURL?: string | null;
1449 interface InteractionData {
1450 interactionCount?: number;
1451 interactionTimeInMilliseconds?: number;
1452 scrollingDistanceInPixels?: number;
1455 interface IntersectionObserverInit {
1456 root?: Element | Document | null;
1457 rootMargin?: string;
1458 threshold?: number | number[];
1461 interface InvokeEventInit extends EventInit {
1463 invoker?: Element | null;
1466 interface KeyboardEventInit extends EventModifierInit {
1469 isComposing?: boolean;
1477 interface KeyframeAnimationOptions extends KeyframeEffectOptions {
1481 interface KeyframeEffectOptions extends EffectTiming {
1482 composite?: CompositeOperation;
1483 iterationComposite?: IterationCompositeOperation;
1484 pseudoElement?: string | null;
1487 interface L10nFileSourceMockFile {
1492 interface L10nIdArgs {
1493 args?: L10nArgs | null;
1497 interface L10nMessage {
1498 attributes?: AttributeNameValue[] | null;
1499 value?: string | null;
1502 interface L10nOverlaysError {
1505 sourceElementName?: string;
1506 translatedElementName?: string;
1509 interface L10nRegistryOptions {
1510 bundleOptions?: FluentBundleOptions;
1513 interface LibcConstants {
1514 AT_EACCESS?: number;
1520 FD_CLOEXEC?: number;
1524 O_NONBLOCK?: number;
1531 PR_CAPBSET_READ?: number;
1535 interface LoadURIOptions {
1536 baseURI?: URI | null;
1537 cancelContentJSEpoch?: number;
1538 csp?: ContentSecurityPolicy | null;
1539 hasValidUserGestureActivation?: boolean;
1540 headers?: InputStream | null;
1542 postData?: InputStream | null;
1543 referrerInfo?: ReferrerInfo | null;
1544 remoteTypeOverride?: string | null;
1545 triggeringPrincipal?: Principal | null;
1546 triggeringRemoteType?: string | null;
1547 triggeringSandboxFlags?: number;
1548 triggeringStorageAccess?: boolean;
1549 triggeringWindowId?: number;
1550 wasSchemelessInput?: boolean;
1553 interface LockInfo {
1559 interface LockManagerSnapshot {
1561 pending?: LockInfo[];
1564 interface LockOptions {
1565 ifAvailable?: boolean;
1567 signal?: AbortSignal;
1571 interface MIDIConnectionEventInit extends EventInit {
1572 port?: MIDIPort | null;
1575 interface MIDIMessageEventInit extends EventInit {
1579 interface MIDIOptions {
1584 interface MakeDirectoryOptions {
1585 createAncestors?: boolean;
1586 ignoreExisting?: boolean;
1587 permissions?: number;
1590 interface MatchPatternOptions {
1591 ignorePath?: boolean;
1592 restrictSchemes?: boolean;
1595 interface MediaCacheStreamDebugInfo {
1596 cacheSuspended?: boolean;
1597 channelEnded?: boolean;
1598 channelOffset?: number;
1600 streamLength?: number;
1603 interface MediaConfiguration {
1604 audio?: AudioConfiguration;
1605 video?: VideoConfiguration;
1608 interface MediaDecoderDebugInfo {
1611 containerType?: string;
1616 reader?: MediaFormatReaderDebugInfo;
1617 resource?: MediaResourceDebugInfo;
1618 stateMachine?: MediaDecoderStateMachineDebugInfo;
1621 interface MediaDecoderStateMachineDebugInfo {
1622 audioCompleted?: boolean;
1623 audioRequestStatus?: string;
1625 decodedAudioEndTime?: number;
1626 decodedVideoEndTime?: number;
1628 isPlaying?: boolean;
1629 mediaSink?: MediaSinkDebugInfo;
1632 sentFirstFrameLoadedEvent?: boolean;
1634 stateObj?: MediaDecoderStateMachineDecodingStateDebugInfo;
1635 totalBufferingTimeMs?: number;
1636 videoCompleted?: boolean;
1637 videoRequestStatus?: string;
1640 interface MediaDecoderStateMachineDecodingStateDebugInfo {
1641 isPrerolling?: boolean;
1644 interface MediaDecodingConfiguration extends MediaConfiguration {
1645 type: MediaDecodingType;
1648 interface MediaElementAudioSourceOptions {
1649 mediaElement: HTMLMediaElement;
1652 interface MediaEncodingConfiguration extends MediaConfiguration {
1653 type: MediaEncodingType;
1656 interface MediaFormatReaderDebugInfo {
1657 audioChannels?: number;
1658 audioDecoderName?: string;
1659 audioFramesDecoded?: number;
1661 audioState?: MediaStateDebugInfo;
1663 frameStats?: MediaFrameStats;
1664 totalReadMetadataTimeMs?: number;
1665 totalWaitingForVideoDataTimeMs?: number;
1666 videoDecoderName?: string;
1667 videoHardwareAccelerated?: boolean;
1668 videoHeight?: number;
1669 videoNumSamplesOutputTotal?: number;
1670 videoNumSamplesSkippedTotal?: number;
1672 videoState?: MediaStateDebugInfo;
1674 videoWidth?: number;
1677 interface MediaFrameStats {
1678 droppedCompositorFrames?: number;
1679 droppedDecodedFrames?: number;
1680 droppedSinkFrames?: number;
1683 interface MediaImage {
1689 interface MediaKeyMessageEventInit extends EventInit {
1690 message: ArrayBuffer;
1691 messageType: MediaKeyMessageType;
1694 interface MediaKeyNeededEventInit extends EventInit {
1695 initData?: ArrayBuffer | null;
1696 initDataType?: string;
1699 interface MediaKeySystemConfiguration {
1700 audioCapabilities?: MediaKeySystemMediaCapability[];
1701 distinctiveIdentifier?: MediaKeysRequirement;
1702 initDataTypes?: string[];
1704 persistentState?: MediaKeysRequirement;
1705 sessionTypes?: string[];
1706 videoCapabilities?: MediaKeySystemMediaCapability[];
1709 interface MediaKeySystemMediaCapability {
1710 contentType?: string;
1711 encryptionScheme?: string | null;
1712 robustness?: string;
1715 interface MediaKeysPolicy {
1716 minHdcpVersion?: HDCPVersion;
1719 interface MediaMetadataInit {
1722 artwork?: MediaImage[];
1726 interface MediaPositionState {
1728 playbackRate?: number;
1732 interface MediaQueryListEventInit extends EventInit {
1737 interface MediaRecorderErrorEventInit extends EventInit {
1738 error: DOMException;
1741 interface MediaRecorderOptions {
1742 audioBitsPerSecond?: number;
1743 bitsPerSecond?: number;
1745 videoBitsPerSecond?: number;
1748 interface MediaResourceDebugInfo {
1749 cacheStream?: MediaCacheStreamDebugInfo;
1752 interface MediaSessionActionDetails {
1753 action: MediaSessionAction;
1755 seekOffset?: number;
1759 interface MediaSinkDebugInfo {
1760 audioSinkWrapper?: AudioSinkWrapperDebugInfo;
1761 decodedStream?: DecodedStreamDebugInfo;
1762 videoSink?: VideoSinkDebugInfo;
1765 interface MediaSourceDecoderDebugInfo {
1766 demuxer?: MediaSourceDemuxerDebugInfo;
1767 reader?: MediaFormatReaderDebugInfo;
1770 interface MediaSourceDemuxerDebugInfo {
1771 audioTrack?: TrackBuffersManagerDebugInfo;
1772 videoTrack?: TrackBuffersManagerDebugInfo;
1775 interface MediaStateDebugInfo {
1777 demuxQueueSize?: number;
1778 drainState?: number;
1779 hasDecoder?: boolean;
1780 hasDemuxRequest?: boolean;
1781 hasPromise?: boolean;
1782 lastStreamSourceID?: number;
1783 needInput?: boolean;
1784 numSamplesInput?: number;
1785 numSamplesOutput?: number;
1788 timeTreshold?: number;
1789 timeTresholdHasSeeked?: boolean;
1790 waitingForData?: boolean;
1791 waitingForKey?: boolean;
1792 waitingPromise?: boolean;
1795 interface MediaStreamAudioSourceOptions {
1796 mediaStream: MediaStream;
1799 interface MediaStreamConstraints {
1800 audio?: boolean | MediaTrackConstraints;
1802 peerIdentity?: string | null;
1804 video?: boolean | MediaTrackConstraints;
1807 interface MediaStreamEventInit extends EventInit {
1808 stream?: MediaStream | null;
1811 interface MediaStreamTrackAudioSourceOptions {
1812 mediaStreamTrack: MediaStreamTrack;
1815 interface MediaStreamTrackEventInit extends EventInit {
1816 track: MediaStreamTrack;
1819 interface MediaTrackConstraintSet {
1820 autoGainControl?: ConstrainBoolean;
1821 browserWindow?: number;
1822 channelCount?: ConstrainLong;
1823 deviceId?: ConstrainDOMString;
1824 echoCancellation?: ConstrainBoolean;
1825 facingMode?: ConstrainDOMString;
1826 frameRate?: ConstrainDouble;
1827 groupId?: ConstrainDOMString;
1828 height?: ConstrainLong;
1829 mediaSource?: string;
1830 noiseSuppression?: ConstrainBoolean;
1831 scrollWithPage?: boolean;
1832 viewportHeight?: ConstrainLong;
1833 viewportOffsetX?: ConstrainLong;
1834 viewportOffsetY?: ConstrainLong;
1835 viewportWidth?: ConstrainLong;
1836 width?: ConstrainLong;
1839 interface MediaTrackConstraints extends MediaTrackConstraintSet {
1840 advanced?: MediaTrackConstraintSet[];
1843 interface MediaTrackSettings {
1844 autoGainControl?: boolean;
1845 browserWindow?: number;
1846 channelCount?: number;
1848 echoCancellation?: boolean;
1849 facingMode?: string;
1853 mediaSource?: string;
1854 noiseSuppression?: boolean;
1855 scrollWithPage?: boolean;
1856 viewportHeight?: number;
1857 viewportOffsetX?: number;
1858 viewportOffsetY?: number;
1859 viewportWidth?: number;
1863 interface MediaTrackSupportedConstraints {
1864 aspectRatio?: boolean;
1865 autoGainControl?: boolean;
1866 browserWindow?: boolean;
1867 channelCount?: boolean;
1869 echoCancellation?: boolean;
1870 facingMode?: boolean;
1871 frameRate?: boolean;
1875 mediaSource?: boolean;
1876 noiseSuppression?: boolean;
1877 sampleRate?: boolean;
1878 sampleSize?: boolean;
1879 scrollWithPage?: boolean;
1880 viewportHeight?: boolean;
1881 viewportOffsetX?: boolean;
1882 viewportOffsetY?: boolean;
1883 viewportWidth?: boolean;
1888 interface MerchantValidationEventInit extends EventInit {
1889 methodName?: string;
1890 validationURL?: string;
1893 interface MessageEventInit extends EventInit {
1895 lastEventId?: string;
1897 ports?: MessagePort[];
1898 source?: MessageEventSource | null;
1901 interface MouseEventInit extends EventModifierInit {
1908 relatedTarget?: EventTarget | null;
1913 interface MoveOptions {
1914 noOverwrite?: boolean;
1917 interface MozApplicationEventInit extends EventInit {
1918 application?: DOMApplication | null;
1921 interface MozDocumentMatcherInit {
1922 allFrames?: boolean;
1923 checkPermissions?: boolean;
1924 excludeGlobs?: MatchGlobOrString[] | null;
1925 excludeMatches?: MatchPatternSetOrStringSequence | null;
1926 frameID?: number | null;
1927 hasActiveTabPermission?: boolean;
1928 includeGlobs?: MatchGlobOrString[] | null;
1929 matchAboutBlank?: boolean;
1930 matchOriginAsFallback?: boolean;
1931 matches: MatchPatternSetOrStringSequence;
1932 originAttributesPatterns?: OriginAttributesPatternDictionary[] | null;
1935 interface MozFrameAncestorInfo {
1940 interface MozHTTPHeader {
1945 interface MozProxyInfo {
1946 connectionIsolationKey?: string | null;
1947 failoverTimeout?: number;
1950 proxyAuthorizationHeader?: string | null;
1953 username?: string | null;
1956 interface MozRequestFilter {
1957 incognito?: boolean | null;
1958 types?: MozContentPolicyType[] | null;
1959 urls?: MatchPatternSet | null;
1962 interface MozRequestMatchOptions {
1966 interface MozUrlClassification {
1967 firstParty: MozUrlClassificationFlags[];
1968 thirdParty: MozUrlClassificationFlags[];
1971 interface MozXMLHttpRequestParameters {
1973 mozSystem?: boolean;
1976 interface MultiCacheQueryOptions extends CacheQueryOptions {
1980 interface MutationObserverInit {
1981 animations?: boolean;
1982 attributeFilter?: string[];
1983 attributeOldValue?: boolean;
1984 attributes?: boolean;
1985 characterData?: boolean;
1986 characterDataOldValue?: boolean;
1987 childList?: boolean;
1988 chromeOnlyNodes?: boolean;
1992 interface MutationObservingInfo extends MutationObserverInit {
1993 observedNode?: Node | null;
1996 interface NavigationPreloadState {
1998 headerValue?: string;
2001 interface NetErrorInfo {
2002 errorCodeString?: string;
2005 interface NotificationBehavior {
2008 showOnlyOnce?: boolean;
2010 vibrationPattern?: number[];
2013 interface NotificationOptions {
2016 dir?: NotificationDirection;
2019 mozbehavior?: NotificationBehavior;
2020 requireInteraction?: boolean;
2023 vibrate?: VibratePattern;
2026 interface ObservableArrayCallbacks {
2027 deleteBooleanCallback?: SetDeleteBooleanCallback;
2028 deleteInterfaceCallback?: SetDeleteInterfaceCallback;
2029 deleteObjectCallback?: SetDeleteObjectCallback;
2030 setBooleanCallback?: SetDeleteBooleanCallback;
2031 setInterfaceCallback?: SetDeleteInterfaceCallback;
2032 setObjectCallback?: SetDeleteObjectCallback;
2035 interface OfflineAudioCompletionEventInit extends EventInit {
2036 renderedBuffer: AudioBuffer;
2039 interface OfflineAudioContextOptions {
2041 numberOfChannels?: number;
2045 interface OpenPopupOptions {
2046 attributesOverride?: boolean;
2047 isContextMenu?: boolean;
2049 triggerEvent?: Event | null;
2054 interface OptionalEffectTiming {
2056 direction?: PlaybackDirection;
2057 duration?: number | string;
2061 iterationStart?: number;
2062 iterations?: number;
2065 interface OpusEncoderConfig {
2066 complexity?: number;
2067 format?: OpusBitstreamFormat;
2068 frameDuration?: number;
2069 packetlossperc?: number;
2071 useinbandfec?: boolean;
2074 interface OriginAttributesDictionary {
2075 firstPartyDomain?: string;
2076 geckoViewSessionContextId?: string;
2077 partitionKey?: string;
2078 privateBrowsingId?: number;
2079 userContextId?: number;
2082 interface OriginAttributesPatternDictionary {
2083 firstPartyDomain?: string;
2084 geckoViewSessionContextId?: string;
2085 partitionKey?: string;
2086 partitionKeyPattern?: PartitionKeyPatternDictionary;
2087 privateBrowsingId?: number;
2088 userContextId?: number;
2091 interface OscillatorOptions extends AudioNodeOptions {
2094 periodicWave?: PeriodicWave;
2095 type?: OscillatorType;
2098 interface PCErrorData {
2103 interface PageTransitionEventInit extends EventInit {
2104 inFrameSwap?: boolean;
2105 persisted?: boolean;
2108 interface PannerOptions extends AudioNodeOptions {
2109 coneInnerAngle?: number;
2110 coneOuterAngle?: number;
2111 coneOuterGain?: number;
2112 distanceModel?: DistanceModelType;
2113 maxDistance?: number;
2114 orientationX?: number;
2115 orientationY?: number;
2116 orientationZ?: number;
2117 panningModel?: PanningModelType;
2121 refDistance?: number;
2122 rolloffFactor?: number;
2125 interface ParentProcInfoDictionary {
2126 children?: ChildProcInfoDictionary[];
2127 cpuCycleCount?: number;
2131 threads?: ThreadInfoDictionary[];
2132 type?: WebIDLProcType;
2135 interface PartitionKeyPatternDictionary {
2136 baseDomain?: string;
2137 foreignByAncestorContext?: boolean;
2142 interface PayerErrors {
2148 interface PaymentCurrencyAmount {
2153 interface PaymentDetailsBase {
2154 displayItems?: PaymentItem[];
2155 modifiers?: PaymentDetailsModifier[];
2156 shippingOptions?: PaymentShippingOption[];
2159 interface PaymentDetailsInit extends PaymentDetailsBase {
2164 interface PaymentDetailsModifier {
2165 additionalDisplayItems?: PaymentItem[];
2167 supportedMethods: string;
2168 total?: PaymentItem;
2171 interface PaymentDetailsUpdate extends PaymentDetailsBase {
2173 payerErrors?: PayerErrors;
2174 paymentMethodErrors?: any;
2175 shippingAddressErrors?: AddressErrors;
2176 total?: PaymentItem;
2179 interface PaymentItem {
2180 amount: PaymentCurrencyAmount;
2185 interface PaymentMethodChangeEventInit extends PaymentRequestUpdateEventInit {
2186 methodDetails?: any;
2187 methodName?: string;
2190 interface PaymentMethodData {
2192 supportedMethods: string;
2195 interface PaymentOptions {
2196 requestBillingAddress?: boolean;
2197 requestPayerEmail?: boolean;
2198 requestPayerName?: boolean;
2199 requestPayerPhone?: boolean;
2200 requestShipping?: boolean;
2201 shippingType?: PaymentShippingType;
2204 interface PaymentRequestUpdateEventInit extends EventInit {
2207 interface PaymentShippingOption {
2208 amount: PaymentCurrencyAmount;
2214 interface PaymentValidationErrors {
2216 payer?: PayerErrors;
2217 paymentMethod?: any;
2218 shippingAddress?: AddressErrors;
2221 interface PerformanceEntryEventInit extends EventInit {
2222 duration?: DOMHighResTimeStamp;
2227 startTime?: DOMHighResTimeStamp;
2230 interface PerformanceEntryFilterOptions {
2232 initiatorType?: string;
2236 interface PerformanceMarkOptions {
2238 startTime?: DOMHighResTimeStamp;
2241 interface PerformanceMeasureOptions {
2243 duration?: DOMHighResTimeStamp;
2244 end?: string | DOMHighResTimeStamp;
2245 start?: string | DOMHighResTimeStamp;
2248 interface PerformanceObserverInit {
2250 durationThreshold?: DOMHighResTimeStamp;
2251 entryTypes?: string[];
2255 interface PeriodicWaveConstraints {
2256 disableNormalization?: boolean;
2259 interface PeriodicWaveOptions extends PeriodicWaveConstraints {
2260 imag?: number[] | Float32Array;
2261 real?: number[] | Float32Array;
2264 interface PermissionSetParameters {
2266 state: PermissionState;
2269 interface PlacesBookmarkAdditionInit {
2278 lastVisitDate: number | null;
2282 tags: string | null;
2283 targetFolderGuid: string | null;
2284 targetFolderItemId: number;
2285 targetFolderTitle: string | null;
2291 interface PlacesBookmarkGuidInit {
2296 lastModified: number;
2299 url?: string | null;
2302 interface PlacesBookmarkKeywordInit {
2308 lastModified: number;
2311 url?: string | null;
2314 interface PlacesBookmarkMovedInit {
2323 lastVisitDate: number | null;
2325 oldParentGuid: string;
2328 tags: string | null;
2330 url?: string | null;
2334 interface PlacesBookmarkRemovedInit {
2338 isDescendantRemoval?: boolean;
2348 interface PlacesBookmarkTagsInit {
2353 lastModified: number;
2357 url?: string | null;
2360 interface PlacesBookmarkTimeInit {
2366 lastModified: number;
2369 url?: string | null;
2372 interface PlacesBookmarkTitleInit {
2377 lastModified: number;
2381 url?: string | null;
2384 interface PlacesBookmarkUrlInit {
2389 lastModified: number;
2395 interface PlacesFaviconInit {
2401 interface PlacesVisitRemovedInit {
2402 isPartialVisistsRemoval?: boolean;
2403 isRemovedFromStore?: boolean;
2406 transitionType?: number;
2410 interface PlacesVisitTitleInit {
2416 interface PlaneLayout {
2421 interface PluginCrashedEventInit extends EventInit {
2422 gmpPlugin?: boolean;
2423 pluginDumpID?: string;
2424 pluginFilename?: string | null;
2426 pluginName?: string;
2427 submittedCrashReport?: boolean;
2430 interface PointerEventInit extends MouseEventInit {
2431 coalescedEvents?: PointerEvent[];
2433 isPrimary?: boolean;
2435 pointerType?: string;
2436 predictedEvents?: PointerEvent[];
2438 tangentialPressure?: number;
2445 interface PopStateEventInit extends EventInit {
2449 interface PopupBlockedEventInit extends EventInit {
2450 popupWindowFeatures?: string;
2451 popupWindowName?: string;
2452 popupWindowURI?: URI | null;
2453 requestingWindow?: Window | null;
2456 interface PopupPositionedEventInit extends EventInit {
2457 alignmentOffset?: number;
2458 alignmentPosition?: string;
2459 isAnchored?: boolean;
2460 popupAlignment?: string;
2463 interface PositionOptions {
2464 enableHighAccuracy?: boolean;
2465 maximumAge?: number;
2469 interface PositionStateEventInit extends EventInit {
2471 playbackRate: number;
2475 interface PrivateAttributionConversionOptions {
2477 histogramSize: number;
2478 impression?: PrivateAttributionImpressionType;
2479 lookbackDays?: number;
2484 interface PrivateAttributionImpressionOptions {
2488 type?: PrivateAttributionImpressionType;
2491 interface ProcessActorChildOptions extends ProcessActorSidedOptions {
2492 observers?: string[];
2495 interface ProcessActorOptions {
2496 child?: ProcessActorChildOptions;
2497 includeParent?: boolean;
2498 loadInDevToolsLoader?: boolean;
2499 parent?: ProcessActorSidedOptions;
2500 remoteTypes?: string[];
2503 interface ProcessActorSidedOptions {
2504 esModuleURI?: string;
2508 interface ProfilerMarkerOptions {
2509 captureStack?: boolean;
2511 innerWindowId?: number;
2512 startTime?: DOMHighResTimeStamp;
2515 interface ProgressEventInit extends EventInit {
2516 lengthComputable?: boolean;
2521 interface PromiseDebuggingStateHolder {
2523 state?: PromiseDebuggingState;
2527 interface PromiseRejectionEventInit extends EventInit {
2528 promise: Promise<any>;
2532 interface PropertyDefinition {
2534 initialValue?: string;
2539 interface PropertyNamesOptions {
2540 includeAliases?: boolean;
2541 includeExperimentals?: boolean;
2542 includeShorthands?: boolean;
2545 interface PropertyPref {
2550 interface PublicKeyCredentialCreationOptions {
2551 attestation?: string;
2552 authenticatorSelection?: AuthenticatorSelectionCriteria;
2553 challenge: BufferSource;
2554 excludeCredentials?: PublicKeyCredentialDescriptor[];
2555 extensions?: AuthenticationExtensionsClientInputs;
2556 pubKeyCredParams: PublicKeyCredentialParameters[];
2557 rp: PublicKeyCredentialRpEntity;
2559 user: PublicKeyCredentialUserEntity;
2562 interface PublicKeyCredentialCreationOptionsJSON {
2563 attestation?: string;
2564 attestationFormats?: string[];
2565 authenticatorSelection?: AuthenticatorSelectionCriteria;
2566 challenge: Base64URLString;
2567 excludeCredentials?: PublicKeyCredentialDescriptorJSON[];
2568 extensions?: AuthenticationExtensionsClientInputsJSON;
2570 pubKeyCredParams: PublicKeyCredentialParameters[];
2571 rp: PublicKeyCredentialRpEntity;
2573 user: PublicKeyCredentialUserEntityJSON;
2576 interface PublicKeyCredentialDescriptor {
2578 transports?: string[];
2582 interface PublicKeyCredentialDescriptorJSON {
2583 id: Base64URLString;
2584 transports?: string[];
2588 interface PublicKeyCredentialEntity {
2592 interface PublicKeyCredentialParameters {
2593 alg: COSEAlgorithmIdentifier;
2597 interface PublicKeyCredentialRequestOptions {
2598 allowCredentials?: PublicKeyCredentialDescriptor[];
2599 challenge: BufferSource;
2600 extensions?: AuthenticationExtensionsClientInputs;
2603 userVerification?: string;
2606 interface PublicKeyCredentialRequestOptionsJSON {
2607 allowCredentials?: PublicKeyCredentialDescriptorJSON[];
2608 attestation?: string;
2609 attestationFormats?: string[];
2610 challenge: Base64URLString;
2611 extensions?: AuthenticationExtensionsClientInputsJSON;
2615 userVerification?: string;
2618 interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
2622 interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
2623 displayName: string;
2627 interface PublicKeyCredentialUserEntityJSON {
2628 displayName: string;
2629 id: Base64URLString;
2633 interface PushSubscriptionInit {
2634 appServerKey?: BufferSource | null;
2635 authSecret?: ArrayBuffer | null;
2637 expirationTime?: EpochTimeStamp | null;
2638 p256dhKey?: ArrayBuffer | null;
2642 interface PushSubscriptionJSON {
2644 expirationTime?: EpochTimeStamp | null;
2645 keys?: PushSubscriptionKeys;
2648 interface PushSubscriptionKeys {
2653 interface PushSubscriptionOptionsInit {
2654 applicationServerKey?: BufferSource | string | null;
2657 interface QueuingStrategy {
2658 highWaterMark?: number;
2659 size?: QueuingStrategySize;
2662 interface QueuingStrategyInit {
2663 highWaterMark: number;
2666 interface RTCBandwidthEstimationInternal {
2667 maxPaddingBps?: number;
2668 pacerDelayMs?: number;
2669 receiveBandwidthBps?: number;
2671 sendBandwidthBps?: number;
2672 trackIdentifier: string;
2675 interface RTCCodecStats extends RTCStats {
2678 codecType?: RTCCodecType;
2680 payloadType: number;
2681 sdpFmtpLine?: string;
2682 transportId: string;
2685 interface RTCConfiguration {
2686 bundlePolicy?: RTCBundlePolicy;
2687 certificates?: RTCCertificate[];
2688 iceServers?: RTCIceServer[];
2689 iceTransportPolicy?: RTCIceTransportPolicy;
2690 peerIdentity?: string | null;
2691 sdpSemantics?: string;
2694 interface RTCConfigurationInternal {
2695 bundlePolicy?: RTCBundlePolicy;
2696 certificatesProvided: boolean;
2697 iceServers?: RTCIceServerInternal[];
2698 iceTransportPolicy?: RTCIceTransportPolicy;
2699 peerIdentityProvided: boolean;
2700 sdpSemantics?: string;
2703 interface RTCDTMFToneChangeEventInit extends EventInit {
2707 interface RTCDataChannelEventInit extends EventInit {
2708 channel: RTCDataChannel;
2711 interface RTCDataChannelInit {
2713 maxPacketLifeTime?: number;
2714 maxRetransmitTime?: number;
2715 maxRetransmits?: number;
2716 negotiated?: boolean;
2721 interface RTCDataChannelStats extends RTCStats {
2722 bytesReceived?: number;
2724 dataChannelIdentifier?: number;
2726 messagesReceived?: number;
2727 messagesSent?: number;
2729 state?: RTCDataChannelState;
2732 interface RTCEncodedAudioFrameMetadata {
2733 contributingSources?: number[];
2734 payloadType?: number;
2735 sequenceNumber?: number;
2736 synchronizationSource?: number;
2739 interface RTCEncodedVideoFrameMetadata {
2740 contributingSources?: number[];
2741 dependencies?: number[];
2744 payloadType?: number;
2745 spatialIndex?: number;
2746 synchronizationSource?: number;
2747 temporalIndex?: number;
2752 interface RTCIceCandidateInit {
2754 sdpMLineIndex?: number | null;
2755 sdpMid?: string | null;
2756 usernameFragment?: string | null;
2759 interface RTCIceCandidatePairStats extends RTCStats {
2760 bytesReceived?: number;
2762 componentId?: number;
2763 lastPacketReceivedTimestamp?: DOMHighResTimeStamp;
2764 lastPacketSentTimestamp?: DOMHighResTimeStamp;
2765 localCandidateId?: string;
2766 nominated?: boolean;
2769 remoteCandidateId?: string;
2771 state?: RTCStatsIceCandidatePairState;
2772 transportId?: string;
2776 interface RTCIceCandidateStats extends RTCStats {
2778 candidateType?: RTCIceCandidateType;
2783 relayProtocol?: string;
2784 transportId?: string;
2787 interface RTCIceServer {
2788 credential?: string;
2789 credentialType?: RTCIceCredentialType;
2791 urls?: string | string[];
2795 interface RTCIceServerInternal {
2796 credentialProvided: boolean;
2798 userNameProvided: boolean;
2801 interface RTCIdentityAssertion {
2806 interface RTCIdentityAssertionResult {
2808 idp: RTCIdentityProviderDetails;
2811 interface RTCIdentityProvider {
2812 generateAssertion: GenerateAssertionCallback;
2813 validateAssertion: ValidateAssertionCallback;
2816 interface RTCIdentityProviderDetails {
2821 interface RTCIdentityProviderOptions {
2822 peerIdentity?: string;
2824 usernameHint?: string;
2827 interface RTCIdentityValidationResult {
2832 interface RTCInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
2833 audioLevel?: number;
2834 bytesReceived?: number;
2835 concealedSamples?: number;
2836 concealmentEvents?: number;
2837 fecPacketsDiscarded?: number;
2838 fecPacketsReceived?: number;
2840 frameHeight?: number;
2841 frameWidth?: number;
2842 framesDecoded?: number;
2843 framesDropped?: number;
2844 framesPerSecond?: number;
2845 framesReceived?: number;
2846 headerBytesReceived?: number;
2847 insertedSamplesForDeceleration?: number;
2848 jitterBufferDelay?: number;
2849 jitterBufferEmittedCount?: number;
2850 lastPacketReceivedTimestamp?: DOMHighResTimeStamp;
2855 removedSamplesForAcceleration?: number;
2856 silentConcealedSamples?: number;
2857 totalAudioEnergy?: number;
2858 totalDecodeTime?: number;
2859 totalInterFrameDelay?: number;
2860 totalProcessingDelay?: number;
2861 totalSamplesDuration?: number;
2862 totalSamplesReceived?: number;
2863 totalSquaredInterFrameDelay?: number;
2864 trackIdentifier: string;
2867 interface RTCLocalSessionDescriptionInit {
2872 interface RTCMediaSourceStats extends RTCStats {
2874 trackIdentifier: string;
2877 interface RTCOfferAnswerOptions {
2880 interface RTCOfferOptions extends RTCOfferAnswerOptions {
2881 iceRestart?: boolean;
2882 offerToReceiveAudio?: boolean;
2883 offerToReceiveVideo?: boolean;
2886 interface RTCOutboundRtpStreamStats extends RTCSentRtpStreamStats {
2888 frameHeight?: number;
2889 frameWidth?: number;
2890 framesEncoded?: number;
2891 framesPerSecond?: number;
2892 framesSent?: number;
2893 headerBytesSent?: number;
2894 hugeFramesSent?: number;
2899 retransmittedBytesSent?: number;
2900 retransmittedPacketsSent?: number;
2901 totalEncodeTime?: number;
2902 totalEncodedBytesTarget?: number;
2905 interface RTCPeerConnectionIceEventInit extends EventInit {
2906 candidate?: RTCIceCandidate | null;
2909 interface RTCPeerConnectionStats extends RTCStats {
2910 dataChannelsClosed?: number;
2911 dataChannelsOpened?: number;
2914 interface RTCRTPContributingSourceStats extends RTCStats {
2915 contributorSsrc?: number;
2916 inboundRtpStreamId?: string;
2919 interface RTCReceivedRtpStreamStats extends RTCRtpStreamStats {
2920 discardedPackets?: number;
2922 packetsDiscarded?: number;
2923 packetsLost?: number;
2924 packetsReceived?: number;
2927 interface RTCRemoteInboundRtpStreamStats extends RTCReceivedRtpStreamStats {
2928 fractionLost?: number;
2930 roundTripTime?: number;
2931 roundTripTimeMeasurements?: number;
2932 totalRoundTripTime?: number;
2935 interface RTCRemoteOutboundRtpStreamStats extends RTCSentRtpStreamStats {
2937 remoteTimestamp?: DOMHighResTimeStamp;
2940 interface RTCRtcpParameters {
2942 reducedSize?: boolean;
2945 interface RTCRtpCapabilities {
2946 codecs: RTCRtpCodec[];
2947 headerExtensions: RTCRtpHeaderExtensionCapability[];
2950 interface RTCRtpCodec {
2954 sdpFmtpLine?: string;
2957 interface RTCRtpCodecParameters extends RTCRtpCodec {
2958 payloadType: number;
2961 interface RTCRtpContributingSource {
2962 audioLevel?: number;
2963 rtpTimestamp: number;
2965 timestamp: DOMHighResTimeStamp;
2968 interface RTCRtpEncodingParameters {
2970 maxBitrate?: number;
2971 maxFramerate?: number;
2972 priority?: RTCPriorityType;
2974 scaleResolutionDownBy?: number;
2977 interface RTCRtpHeaderExtensionCapability {
2981 interface RTCRtpHeaderExtensionParameters {
2982 encrypted?: boolean;
2987 interface RTCRtpParameters {
2988 codecs?: RTCRtpCodecParameters[];
2989 headerExtensions?: RTCRtpHeaderExtensionParameters[];
2990 rtcp?: RTCRtcpParameters;
2993 interface RTCRtpReceiveParameters extends RTCRtpParameters {
2996 interface RTCRtpSendParameters extends RTCRtpParameters {
2997 encodings: RTCRtpEncodingParameters[];
2998 transactionId?: string;
3001 interface RTCRtpStreamStats extends RTCStats {
3006 transportId?: string;
3009 interface RTCRtpSynchronizationSource extends RTCRtpContributingSource {
3010 voiceActivityFlag?: boolean | null;
3013 interface RTCRtpTransceiverInit {
3014 direction?: RTCRtpTransceiverDirection;
3015 sendEncodings?: RTCRtpEncodingParameters[];
3016 streams?: MediaStream[];
3019 interface RTCSdpHistoryEntryInternal {
3020 errors?: RTCSdpParsingErrorInternal[];
3023 timestamp: DOMHighResTimeStamp;
3026 interface RTCSdpHistoryInternal {
3028 sdpHistory?: RTCSdpHistoryEntryInternal[];
3031 interface RTCSdpParsingErrorInternal {
3036 interface RTCSentRtpStreamStats extends RTCRtpStreamStats {
3038 packetsSent?: number;
3041 interface RTCSessionDescriptionInit {
3046 interface RTCStats {
3048 timestamp?: DOMHighResTimeStamp;
3049 type?: RTCStatsType;
3052 interface RTCStatsCollection {
3053 bandwidthEstimations?: RTCBandwidthEstimationInternal[];
3054 codecStats?: RTCCodecStats[];
3055 dataChannelStats?: RTCDataChannelStats[];
3056 iceCandidatePairStats?: RTCIceCandidatePairStats[];
3057 iceCandidateStats?: RTCIceCandidateStats[];
3058 inboundRtpStreamStats?: RTCInboundRtpStreamStats[];
3059 mediaSourceStats?: RTCMediaSourceStats[];
3060 outboundRtpStreamStats?: RTCOutboundRtpStreamStats[];
3061 peerConnectionStats?: RTCPeerConnectionStats[];
3062 rawLocalCandidates?: string[];
3063 rawRemoteCandidates?: string[];
3064 remoteInboundRtpStreamStats?: RTCRemoteInboundRtpStreamStats[];
3065 remoteOutboundRtpStreamStats?: RTCRemoteOutboundRtpStreamStats[];
3066 rtpContributingSourceStats?: RTCRTPContributingSourceStats[];
3067 trickledIceCandidateStats?: RTCIceCandidateStats[];
3068 videoFrameHistories?: RTCVideoFrameHistoryInternal[];
3069 videoSourceStats?: RTCVideoSourceStats[];
3072 interface RTCStatsReportInternal extends RTCStatsCollection {
3074 callDurationMs?: number;
3076 configuration?: RTCConfigurationInternal;
3077 iceRestarts: number;
3078 iceRollbacks: number;
3079 jsepSessionErrors?: string;
3082 sdpHistory?: RTCSdpHistoryEntryInternal[];
3083 timestamp: DOMHighResTimeStamp;
3086 interface RTCTrackEventInit extends EventInit {
3087 receiver: RTCRtpReceiver;
3088 streams?: MediaStream[];
3089 track: MediaStreamTrack;
3090 transceiver: RTCRtpTransceiver;
3093 interface RTCVideoFrameHistoryEntryInternal {
3094 consecutiveFrames: number;
3095 firstFrameTimestamp: DOMHighResTimeStamp;
3097 lastFrameTimestamp: DOMHighResTimeStamp;
3100 rotationAngle: number;
3104 interface RTCVideoFrameHistoryInternal {
3105 entries?: RTCVideoFrameHistoryEntryInternal[];
3106 trackIdentifier: string;
3109 interface RTCVideoSourceStats extends RTCMediaSourceStats {
3111 framesPerSecond?: number;
3116 interface ReadOptions extends ReadUTF8Options {
3117 maxBytes?: number | null;
3121 interface ReadUTF8Options {
3122 decompress?: boolean;
3125 interface ReadableStreamGetReaderOptions {
3126 mode?: ReadableStreamReaderMode;
3129 interface ReadableStreamIteratorOptions {
3130 preventCancel?: boolean;
3133 interface ReadableStreamReadResult {
3138 interface ReadableWritablePair {
3139 readable: ReadableStream;
3140 writable: WritableStream;
3143 interface ReceiveMessageArgument {
3147 ports?: MessagePort[];
3149 target: nsISupports;
3150 targetFrameLoader?: FrameLoader;
3153 interface RegistrationOptions {
3155 updateViaCache?: ServiceWorkerUpdateViaCache;
3158 interface RemotenessOptions {
3159 pendingSwitchID?: number;
3160 remoteType: string | null;
3161 switchingInProgressLoad?: boolean;
3164 interface RemoveOptions {
3165 ignoreAbsent?: boolean;
3166 recursive?: boolean;
3167 retryReadonly?: boolean;
3170 interface ReportingObserverOptions {
3175 interface RequestInit {
3176 body?: BodyInit | null;
3177 cache?: RequestCache;
3178 credentials?: RequestCredentials;
3179 headers?: HeadersInit;
3181 keepalive?: boolean;
3184 mozErrors?: boolean;
3185 observe?: ObserverCallback;
3186 priority?: RequestPriority;
3187 redirect?: RequestRedirect;
3189 referrerPolicy?: ReferrerPolicy;
3190 signal?: AbortSignal | null;
3193 interface ResizeObserverOptions {
3194 box?: ResizeObserverBoxOptions;
3197 interface ResourceId {
3202 interface ResponseInit {
3203 headers?: HeadersInit;
3205 statusText?: string;
3208 interface SVGBoundingBoxOptions {
3215 interface SanitizerAttributeNamespace {
3217 namespace?: string | null;
3220 interface SanitizerConfig {
3221 attributes?: SanitizerAttribute[];
3223 customElements?: boolean;
3224 elements?: SanitizerElementWithAttributes[];
3225 removeAttributes?: SanitizerAttribute[];
3226 removeElements?: SanitizerElement[];
3227 replaceWithChildrenElements?: SanitizerElement[];
3228 unknownMarkup?: boolean;
3231 interface SanitizerElementNamespace {
3233 namespace?: string | null;
3236 interface SanitizerElementNamespaceWithAttributes extends SanitizerElementNamespace {
3237 attributes?: SanitizerAttribute[];
3238 removeAttributes?: SanitizerAttribute[];
3241 interface SchedulerPostTaskOptions {
3243 priority?: TaskPriority;
3244 signal?: AbortSignal;
3247 interface ScrollIntoViewOptions extends ScrollOptions {
3248 block?: ScrollLogicalPosition;
3249 inline?: ScrollLogicalPosition;
3252 interface ScrollOptions {
3253 behavior?: ScrollBehavior;
3256 interface ScrollToOptions extends ScrollOptions {
3261 interface ScrollViewChangeEventInit extends EventInit {
3262 state?: ScrollState;
3265 interface SecurityPolicyViolationEventInit extends EventInit {
3266 blockedURI?: string;
3267 columnNumber?: number;
3268 disposition?: SecurityPolicyViolationEventDisposition;
3269 documentURI?: string;
3270 effectiveDirective?: string;
3271 lineNumber?: number;
3272 originalPolicy?: string;
3275 sourceFile?: string;
3276 statusCode?: number;
3277 violatedDirective?: string;
3280 interface SelectorWarning {
3282 kind: SelectorWarningKind;
3285 interface ServerSocketOptions {
3286 binaryType?: TCPSocketBinaryType;
3289 interface SetHTMLOptions {
3290 sanitizer?: SanitizerConfig;
3293 interface ShadowRootInit {
3295 delegatesFocus?: boolean;
3296 mode: ShadowRootMode;
3297 serializable?: boolean;
3298 slotAssignment?: SlotAssignmentMode;
3301 interface ShareData {
3308 interface SizeToContentConstraints {
3314 interface SocketOptions {
3315 binaryType?: TCPSocketBinaryType;
3316 useSecureTransport?: boolean;
3319 interface SpeechRecognitionErrorInit extends EventInit {
3320 error?: SpeechRecognitionErrorCode;
3324 interface SpeechRecognitionEventInit extends EventInit {
3325 emma?: Document | null;
3326 interpretation?: any;
3327 resultIndex?: number;
3328 results?: SpeechRecognitionResultList | null;
3331 interface SpeechSynthesisErrorEventInit extends SpeechSynthesisEventInit {
3332 error: SpeechSynthesisErrorCode;
3335 interface SpeechSynthesisEventInit extends EventInit {
3337 charLength?: number | null;
3338 elapsedTime?: number;
3340 utterance: SpeechSynthesisUtterance;
3343 interface SplitRelativeOptions {
3344 allowCurrentDir?: boolean;
3345 allowEmpty?: boolean;
3346 allowParentDir?: boolean;
3349 interface StaticRangeInit {
3352 startContainer: Node;
3353 startOffset: number;
3356 interface StereoPannerOptions extends AudioNodeOptions {
3360 interface StorageEstimate {
3365 interface StorageEventInit extends EventInit {
3366 key?: string | null;
3367 newValue?: string | null;
3368 oldValue?: string | null;
3369 storageArea?: Storage | null;
3373 interface StreamFilterDataEventInit extends EventInit {
3377 interface StreamPipeOptions {
3378 preventAbort?: boolean;
3379 preventCancel?: boolean;
3380 preventClose?: boolean;
3381 signal?: AbortSignal;
3384 interface StructuredSerializeOptions {
3388 interface StyleSheetApplicableStateChangeEventInit extends EventInit {
3389 applicable?: boolean;
3390 stylesheet?: CSSStyleSheet | null;
3393 interface StyleSheetRemovedEventInit extends EventInit {
3394 stylesheet?: CSSStyleSheet | null;
3397 interface SubmitEventInit extends EventInit {
3398 submitter?: HTMLElement | null;
3401 interface SupportsOptions {
3404 userAgent?: boolean;
3407 interface SvcOutputMetadata {
3408 temporalLayerId?: number;
3411 interface TCPServerSocketEventInit extends EventInit {
3412 socket?: TCPSocket | null;
3415 interface TCPSocketErrorEventInit extends EventInit {
3421 interface TCPSocketEventInit extends EventInit {
3425 interface TaskControllerInit {
3426 priority?: TaskPriority;
3429 interface TaskPriorityChangeEventInit extends EventInit {
3430 previousPriority: TaskPriority;
3433 interface TelemetryStopwatchOptions {
3434 inSeconds?: boolean;
3437 interface TestInterfaceAsyncIterableSingleOptions {
3438 failToInit?: boolean;
3441 interface TestInterfaceAsyncIteratorOptions {
3442 blockingPromises?: Promise<any>[];
3443 failNextAfter?: number;
3444 multiplier?: number;
3445 throwFromNext?: boolean;
3446 throwFromReturn?: TestThrowingCallback;
3449 interface TestInterfaceJSDictionary {
3451 anySequenceMember?: any[];
3452 innerDictionary?: TestInterfaceJSDictionary2;
3454 objectOrStringMember?: any;
3455 objectRecordMember?: Record<string, any>;
3458 interface TestInterfaceJSDictionary2 {
3462 interface TestInterfaceJSUnionableDictionary {
3467 interface TextDecodeOptions {
3471 interface TextDecoderOptions {
3473 ignoreBOM?: boolean;
3476 interface TextEncoderEncodeIntoResult {
3481 interface ThreadInfoDictionary {
3482 cpuCycleCount?: number;
3488 interface ToggleEventInit extends EventInit {
3493 interface TouchEventInit extends EventModifierInit {
3494 changedTouches?: Touch[];
3495 targetTouches?: Touch[];
3499 interface TouchInit {
3508 rotationAngle?: number;
3511 target: EventTarget;
3514 interface TrackBuffersManagerDebugInfo {
3515 bufferSize?: number;
3517 nextGetSampleIndex?: number;
3518 nextInsertionIndex?: number;
3519 nextSampleTime?: number;
3520 numSamples?: number;
3521 ranges?: BufferRange[];
3525 interface TrackEventInit extends EventInit {
3526 track?: VideoTrack | AudioTrack | TextTrack | null;
3529 interface TransitionEventInit extends EventInit {
3530 elapsedTime?: number;
3531 propertyName?: string;
3532 pseudoElement?: string;
3535 interface TreeCellInfo {
3537 col?: TreeColumn | null;
3541 interface TrustedTypePolicyOptions {
3542 createHTML?: CreateHTMLCallback;
3543 createScript?: CreateScriptCallback;
3544 createScriptURL?: CreateScriptURLCallback;
3547 interface UDPMessageEventInit extends EventInit {
3549 remoteAddress?: string;
3550 remotePort?: number;
3553 interface UDPOptions {
3554 addressReuse?: boolean;
3555 localAddress?: string;
3558 remoteAddress?: string;
3559 remotePort?: number;
3562 interface UIEventInit extends EventInit {
3564 view?: Window | null;
3567 interface UniFFIScaffoldingCallResult {
3568 code: UniFFIScaffoldingCallCode;
3569 data?: UniFFIScaffoldingValue;
3570 internalErrorMessage?: string;
3573 interface UserProximityEventInit extends EventInit {
3577 interface UtilityActorsDictionary {
3578 actorName?: WebIDLUtilityActorName;
3581 interface VRDisplayEventInit extends EventInit {
3583 reason?: VRDisplayEventReason;
3587 leftBounds?: number[] | Float32Array;
3588 rightBounds?: number[] | Float32Array;
3589 source?: HTMLCanvasElement | null;
3592 interface ValidityStateFlags {
3594 customError?: boolean;
3595 patternMismatch?: boolean;
3596 rangeOverflow?: boolean;
3597 rangeUnderflow?: boolean;
3598 stepMismatch?: boolean;
3601 typeMismatch?: boolean;
3602 valueMissing?: boolean;
3605 interface VideoColorSpaceInit {
3606 fullRange?: boolean | null;
3607 matrix?: VideoMatrixCoefficients | null;
3608 primaries?: VideoColorPrimaries | null;
3609 transfer?: VideoTransferCharacteristics | null;
3612 interface VideoConfiguration {
3614 colorGamut?: ColorGamut;
3615 contentType: string;
3617 hasAlphaChannel?: boolean;
3618 hdrMetadataType?: HdrMetadataType;
3620 scalabilityMode?: string;
3621 transferFunction?: TransferFunction;
3625 interface VideoDecoderConfig {
3627 codedHeight?: number;
3628 codedWidth?: number;
3629 colorSpace?: VideoColorSpaceInit;
3630 description?: ArrayBufferView | ArrayBuffer;
3631 displayAspectHeight?: number;
3632 displayAspectWidth?: number;
3633 hardwareAcceleration?: HardwareAcceleration;
3634 optimizeForLatency?: boolean;
3637 interface VideoDecoderInit {
3638 error: WebCodecsErrorCallback;
3639 output: VideoFrameOutputCallback;
3642 interface VideoDecoderSupport {
3643 config?: VideoDecoderConfig;
3644 supported?: boolean;
3647 interface VideoEncoderConfig {
3648 alpha?: AlphaOption;
3649 avc?: AvcEncoderConfig;
3651 bitrateMode?: VideoEncoderBitrateMode;
3653 contentHint?: string;
3654 displayHeight?: number;
3655 displayWidth?: number;
3657 hardwareAcceleration?: HardwareAcceleration;
3659 latencyMode?: LatencyMode;
3660 scalabilityMode?: string;
3664 interface VideoEncoderEncodeOptions {
3665 avc?: VideoEncoderEncodeOptionsForAvc;
3669 interface VideoEncoderEncodeOptionsForAvc {
3670 quantizer?: number | null;
3673 interface VideoEncoderInit {
3674 error: WebCodecsErrorCallback;
3675 output: EncodedVideoChunkOutputCallback;
3678 interface VideoEncoderSupport {
3679 config?: VideoEncoderConfig;
3680 supported?: boolean;
3683 interface VideoFrameBufferInit {
3684 codedHeight: number;
3686 colorSpace?: VideoColorSpaceInit;
3687 displayHeight?: number;
3688 displayWidth?: number;
3690 format: VideoPixelFormat;
3691 layout?: PlaneLayout[];
3693 visibleRect?: DOMRectInit;
3696 interface VideoFrameCopyToOptions {
3697 layout?: PlaneLayout[];
3701 interface VideoFrameInit {
3702 alpha?: AlphaOption;
3703 displayHeight?: number;
3704 displayWidth?: number;
3707 visibleRect?: DOMRectInit;
3710 interface VideoSinkDebugInfo {
3711 endPromiseHolderIsEmpty?: boolean;
3714 isPlaying?: boolean;
3715 isStarted?: boolean;
3717 videoFrameEndTime?: number;
3718 videoSinkEndRequestExists?: boolean;
3721 interface WaveShaperOptions extends AudioNodeOptions {
3722 curve?: number[] | Float32Array;
3723 oversample?: OverSampleType;
3726 interface WebAccessibleResourceInit {
3727 extension_ids?: string[] | null;
3728 matches?: MatchPatternSetOrStringSequence | null;
3729 resources: MatchGlobOrString[];
3732 interface WebExtensionContentScriptInit extends MozDocumentMatcherInit {
3733 cssPaths?: string[];
3735 runAt?: ContentScriptRunAt;
3736 world?: ContentScriptExecutionWorld;
3739 interface WebExtensionInit {
3740 allowedOrigins: MatchPatternSetOrStringSequence;
3741 backgroundScripts?: string[] | null;
3742 backgroundTypeModule?: boolean;
3743 backgroundWorkerScript?: string | null;
3745 contentScripts?: WebExtensionContentScriptInit[];
3746 extensionPageCSP?: string | null;
3748 ignoreQuarantine?: boolean;
3749 isPrivileged?: boolean;
3750 localizeCallback: WebExtensionLocalizeCallback;
3751 manifestVersion?: number;
3752 mozExtensionHostname: string;
3754 permissions?: string[];
3755 readyPromise?: Promise<WebExtensionPolicy | null>;
3756 temporarilyInstalled?: boolean;
3758 webAccessibleResources?: WebAccessibleResourceInit[];
3761 interface WebGLContextAttributes {
3763 antialias?: GLboolean;
3764 colorSpace?: PredefinedColorSpace;
3766 failIfMajorPerformanceCaveat?: GLboolean;
3767 powerPreference?: WebGLPowerPreference;
3768 premultipliedAlpha?: GLboolean;
3769 preserveDrawingBuffer?: GLboolean;
3770 stencil?: GLboolean;
3771 xrCompatible?: boolean;
3774 interface WebGLContextEventInit extends EventInit {
3775 statusMessage?: string;
3778 interface WebTransportCloseInfo {
3783 interface WebTransportDatagramStats {
3784 droppedIncoming?: number;
3785 expiredOutgoing?: number;
3786 lostOutgoing?: number;
3787 timestamp?: DOMHighResTimeStamp;
3790 interface WebTransportErrorInit {
3792 streamErrorCode?: number;
3795 interface WebTransportHash {
3797 value?: BufferSource;
3800 interface WebTransportOptions {
3801 allowPooling?: boolean;
3802 congestionControl?: WebTransportCongestionControl;
3803 requireUnreliable?: boolean;
3804 serverCertificateHashes?: WebTransportHash[];
3807 interface WebTransportReceiveStreamStats {
3809 bytesReceived?: number;
3810 timestamp?: DOMHighResTimeStamp;
3813 interface WebTransportSendStreamOptions {
3814 sendOrder?: number | null;
3817 interface WebTransportSendStreamStats {
3818 bytesAcknowledged?: number;
3820 bytesWritten?: number;
3821 timestamp?: DOMHighResTimeStamp;
3824 interface WebTransportStats {
3825 bytesReceived?: number;
3827 datagrams?: WebTransportDatagramStats;
3828 minRtt?: DOMHighResTimeStamp;
3829 numIncomingStreamsCreated?: number;
3830 numOutgoingStreamsCreated?: number;
3831 packetsLost?: number;
3832 packetsReceived?: number;
3833 packetsSent?: number;
3834 rttVariation?: DOMHighResTimeStamp;
3835 smoothedRtt?: DOMHighResTimeStamp;
3836 timestamp?: DOMHighResTimeStamp;
3839 interface WebrtcGlobalMediaContext {
3840 hasH264Hardware: boolean;
3843 interface WebrtcGlobalStatisticsReport {
3844 reports?: RTCStatsReportInternal[];
3845 sdpHistories?: RTCSdpHistoryInternal[];
3848 interface WheelEventInit extends MouseEventInit {
3855 interface WindowActorChildOptions extends WindowActorSidedOptions {
3856 events?: Record<string, WindowActorEventListenerOptions>;
3857 observers?: string[];
3860 interface WindowActorEventListenerOptions extends AddEventListenerOptions {
3861 createActor?: boolean;
3864 interface WindowActorOptions {
3865 allFrames?: boolean;
3866 child?: WindowActorChildOptions;
3867 includeChrome?: boolean;
3869 messageManagerGroups?: string[];
3870 parent?: WindowActorSidedOptions;
3871 remoteTypes?: string[];
3874 interface WindowActorSidedOptions {
3875 esModuleURI?: string;
3879 interface WindowInfoDictionary {
3880 documentTitle?: string;
3881 documentURI?: URI | null;
3882 isInProcess?: boolean;
3883 isProcessRoot?: boolean;
3884 outerWindowId?: number;
3887 interface WindowPostMessageOptions extends StructuredSerializeOptions {
3888 targetOrigin?: string;
3891 interface WindowsFileAttributes {
3897 interface Wireframe {
3898 canvasBackground?: number;
3899 rects?: WireframeTaggedRect[];
3903 interface WireframeTaggedRect {
3907 type?: WireframeRectType;
3913 interface WorkerOptions {
3914 credentials?: RequestCredentials;
3919 interface WorkletOptions {
3920 credentials?: RequestCredentials;
3923 interface WriteOptions {
3924 backupFile?: string;
3931 interface WriteParams {
3932 data?: BufferSource | Blob | string | null;
3933 position?: number | null;
3934 size?: number | null;
3935 type: WriteCommandType;
3938 interface XRInputSourceEventInit extends EventInit {
3940 inputSource: XRInputSource;
3943 interface XRInputSourcesChangeEventInit extends EventInit {
3944 added: XRInputSource[];
3945 removed: XRInputSource[];
3949 interface XRReferenceSpaceEventInit extends EventInit {
3950 referenceSpace: XRReferenceSpace;
3951 transform?: XRRigidTransform | null;
3954 interface XRRenderStateInit {
3955 baseLayer?: XRWebGLLayer | null;
3958 inlineVerticalFieldOfView?: number;
3961 interface XRSessionEventInit extends EventInit {
3965 interface XRSessionInit {
3966 optionalFeatures?: string[];
3967 requiredFeatures?: string[];
3970 interface XRWebGLLayerInit {
3972 antialias?: boolean;
3974 framebufferScaleFactor?: number;
3975 ignoreDepthValues?: boolean;
3979 interface addonInstallOptions {
3980 hash?: string | null;
3984 interface sendAbuseReportOptions {
3985 authorization?: string | null;
3988 type EventListener = ((event: Event) => void) | { handleEvent(event: Event): void; };
3990 type MessageListener = ((argument: ReceiveMessageArgument) => any) | { receiveMessage(argument: ReceiveMessageArgument): any; };
3992 type MozDocumentCallback = ((matcher: MozDocumentMatcher, window: WindowProxy) => void) | { onNewDocument(matcher: MozDocumentMatcher, window: WindowProxy): void; };
3994 type NodeFilter = ((node: Node) => number) | { acceptNode(node: Node): number; };
3996 declare var NodeFilter: {
3997 readonly FILTER_ACCEPT: 1;
3998 readonly FILTER_REJECT: 2;
3999 readonly FILTER_SKIP: 3;
4000 readonly SHOW_ALL: 0xFFFFFFFF;
4001 readonly SHOW_ELEMENT: 0x1;
4002 readonly SHOW_ATTRIBUTE: 0x2;
4003 readonly SHOW_TEXT: 0x4;
4004 readonly SHOW_CDATA_SECTION: 0x8;
4005 readonly SHOW_ENTITY_REFERENCE: 0x10;
4006 readonly SHOW_ENTITY: 0x20;
4007 readonly SHOW_PROCESSING_INSTRUCTION: 0x40;
4008 readonly SHOW_COMMENT: 0x80;
4009 readonly SHOW_DOCUMENT: 0x100;
4010 readonly SHOW_DOCUMENT_TYPE: 0x200;
4011 readonly SHOW_DOCUMENT_FRAGMENT: 0x400;
4012 readonly SHOW_NOTATION: 0x800;
4015 type ObserverCallback = ((observer: FetchObserver) => void) | { handleEvent(observer: FetchObserver): void; };
4017 type UncaughtRejectionObserver = ((p: any) => boolean) | { onLeftUncaught(p: any): boolean; };
4019 type XPathNSResolver = ((prefix: string | null) => string | null) | { lookupNamespaceURI(prefix: string | null): string | null; };
4021 interface ANGLE_instanced_arrays {
4022 drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;
4023 drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;
4024 vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;
4025 readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88FE;
4028 interface ARIAMixin {
4029 ariaActiveDescendantElement: Element | null;
4030 ariaAtomic: string | null;
4031 ariaAutoComplete: string | null;
4032 ariaBrailleLabel: string | null;
4033 ariaBrailleRoleDescription: string | null;
4034 ariaBusy: string | null;
4035 ariaChecked: string | null;
4036 ariaColCount: string | null;
4037 ariaColIndex: string | null;
4038 ariaColIndexText: string | null;
4039 ariaColSpan: string | null;
4040 ariaCurrent: string | null;
4041 ariaDescription: string | null;
4042 ariaDisabled: string | null;
4043 ariaExpanded: string | null;
4044 ariaHasPopup: string | null;
4045 ariaHidden: string | null;
4046 ariaInvalid: string | null;
4047 ariaKeyShortcuts: string | null;
4048 ariaLabel: string | null;
4049 ariaLevel: string | null;
4050 ariaLive: string | null;
4051 ariaModal: string | null;
4052 ariaMultiLine: string | null;
4053 ariaMultiSelectable: string | null;
4054 ariaOrientation: string | null;
4055 ariaPlaceholder: string | null;
4056 ariaPosInSet: string | null;
4057 ariaPressed: string | null;
4058 ariaReadOnly: string | null;
4059 ariaRelevant: string | null;
4060 ariaRequired: string | null;
4061 ariaRoleDescription: string | null;
4062 ariaRowCount: string | null;
4063 ariaRowIndex: string | null;
4064 ariaRowIndexText: string | null;
4065 ariaRowSpan: string | null;
4066 ariaSelected: string | null;
4067 ariaSetSize: string | null;
4068 ariaSort: string | null;
4069 ariaValueMax: string | null;
4070 ariaValueMin: string | null;
4071 ariaValueNow: string | null;
4072 ariaValueText: string | null;
4073 role: string | null;
4076 interface AbortController {
4077 readonly signal: AbortSignal;
4078 abort(reason?: any): void;
4081 declare var AbortController: {
4082 prototype: AbortController;
4083 new(): AbortController;
4084 isInstance: IsInstance<AbortController>;
4087 interface AbortSignalEventMap {
4091 interface AbortSignal extends EventTarget {
4092 readonly aborted: boolean;
4093 onabort: ((this: AbortSignal, ev: Event) => any) | null;
4094 readonly reason: any;
4095 throwIfAborted(): void;
4096 addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4097 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4098 removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4099 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4102 declare var AbortSignal: {
4103 prototype: AbortSignal;
4105 isInstance: IsInstance<AbortSignal>;
4106 abort(reason?: any): AbortSignal;
4107 any(signals: AbortSignal[]): AbortSignal;
4108 timeout(milliseconds: number): AbortSignal;
4111 interface AbstractRange {
4112 readonly collapsed: boolean;
4113 readonly endContainer: Node;
4114 readonly endOffset: number;
4115 readonly startContainer: Node;
4116 readonly startOffset: number;
4119 declare var AbstractRange: {
4120 prototype: AbstractRange;
4121 new(): AbstractRange;
4122 isInstance: IsInstance<AbstractRange>;
4125 interface AbstractWorkerEventMap {
4129 interface AbstractWorker {
4130 onerror: ((this: AbstractWorker, ev: Event) => any) | null;
4131 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4132 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4133 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4134 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4137 interface AccessibleNode {
4138 readonly DOMNode: Node | null;
4139 activeDescendant: AccessibleNode | null;
4140 atomic: boolean | null;
4141 readonly attributes: string[];
4142 autocomplete: string | null;
4143 busy: boolean | null;
4144 checked: string | null;
4145 colCount: number | null;
4146 colIndex: number | null;
4147 colSpan: number | null;
4148 readonly computedRole: string;
4149 current: string | null;
4150 details: AccessibleNode | null;
4151 disabled: boolean | null;
4152 errorMessage: AccessibleNode | null;
4153 expanded: boolean | null;
4154 hasPopUp: string | null;
4155 hidden: boolean | null;
4156 invalid: string | null;
4157 keyShortcuts: string | null;
4158 label: string | null;
4159 level: number | null;
4160 live: string | null;
4161 modal: boolean | null;
4162 multiline: boolean | null;
4163 multiselectable: boolean | null;
4164 orientation: string | null;
4165 placeholder: string | null;
4166 posInSet: number | null;
4167 pressed: string | null;
4168 readOnly: boolean | null;
4169 relevant: string | null;
4170 required: boolean | null;
4171 role: string | null;
4172 roleDescription: string | null;
4173 rowCount: number | null;
4174 rowIndex: number | null;
4175 rowSpan: number | null;
4176 selected: boolean | null;
4177 setSize: number | null;
4178 sort: string | null;
4179 readonly states: string[];
4180 valueMax: number | null;
4181 valueMin: number | null;
4182 valueNow: number | null;
4183 valueText: string | null;
4184 get(attribute: string): any;
4185 has(...attributes: string[]): boolean;
4186 is(...states: string[]): boolean;
4189 declare var AccessibleNode: {
4190 prototype: AccessibleNode;
4191 new(): AccessibleNode;
4192 isInstance: IsInstance<AccessibleNode>;
4196 readonly canUninstall: boolean;
4197 readonly description: string;
4198 readonly id: string;
4199 readonly isActive: boolean;
4200 readonly isEnabled: boolean;
4201 readonly name: string;
4202 readonly type: string;
4203 readonly version: string;
4204 setEnabled(value: boolean): Promise<void>;
4205 uninstall(): Promise<boolean>;
4208 declare var Addon: {
4211 isInstance: IsInstance<Addon>;
4214 interface AddonEvent extends Event {
4215 readonly id: string;
4218 declare var AddonEvent: {
4219 prototype: AddonEvent;
4220 new(type: string, eventInitDict: AddonEventInit): AddonEvent;
4221 isInstance: IsInstance<AddonEvent>;
4224 interface AddonInstall extends EventTarget {
4225 readonly error: string | null;
4226 readonly maxProgress: number;
4227 readonly progress: number;
4228 readonly state: string;
4229 cancel(): Promise<void>;
4230 install(): Promise<void>;
4233 declare var AddonInstall: {
4234 prototype: AddonInstall;
4235 new(): AddonInstall;
4236 isInstance: IsInstance<AddonInstall>;
4239 interface AddonManager extends EventTarget {
4240 createInstall(options?: addonInstallOptions): Promise<AddonInstall>;
4241 getAddonByID(id: string): Promise<Addon>;
4242 sendAbuseReport(addonId: string, data: Record<string, string | null>, options?: sendAbuseReportOptions): Promise<any>;
4245 declare var AddonManager: {
4246 prototype: AddonManager;
4247 new(): AddonManager;
4248 isInstance: IsInstance<AddonManager>;
4251 interface AnalyserNode extends AudioNode, AudioNodePassThrough {
4253 readonly frequencyBinCount: number;
4254 maxDecibels: number;
4255 minDecibels: number;
4256 smoothingTimeConstant: number;
4257 getByteFrequencyData(array: Uint8Array): void;
4258 getByteTimeDomainData(array: Uint8Array): void;
4259 getFloatFrequencyData(array: Float32Array): void;
4260 getFloatTimeDomainData(array: Float32Array): void;
4263 declare var AnalyserNode: {
4264 prototype: AnalyserNode;
4265 new(context: BaseAudioContext, options?: AnalyserOptions): AnalyserNode;
4266 isInstance: IsInstance<AnalyserNode>;
4269 interface Animatable {
4270 animate(keyframes: any, options?: UnrestrictedDoubleOrKeyframeAnimationOptions): Animation;
4271 getAnimations(options?: GetAnimationsOptions): Animation[];
4274 interface AnimationEventMap {
4280 interface Animation extends EventTarget {
4281 currentTime: number | null;
4282 effect: AnimationEffect | null;
4283 readonly finished: Promise<Animation>;
4285 readonly isRunningOnCompositor: boolean;
4286 oncancel: ((this: Animation, ev: Event) => any) | null;
4287 onfinish: ((this: Animation, ev: Event) => any) | null;
4288 onremove: ((this: Animation, ev: Event) => any) | null;
4289 readonly pending: boolean;
4290 readonly playState: AnimationPlayState;
4291 playbackRate: number;
4292 readonly ready: Promise<Animation>;
4293 readonly replaceState: AnimationReplaceState;
4294 startTime: number | null;
4295 timeline: AnimationTimeline | null;
4297 commitStyles(): void;
4303 updatePlaybackRate(playbackRate: number): void;
4304 addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4305 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4306 removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: Animation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4307 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4310 declare var Animation: {
4311 prototype: Animation;
4312 new(effect?: AnimationEffect | null, timeline?: AnimationTimeline | null): Animation;
4313 isInstance: IsInstance<Animation>;
4316 interface AnimationEffect {
4317 getComputedTiming(): ComputedEffectTiming;
4318 getTiming(): EffectTiming;
4319 updateTiming(timing?: OptionalEffectTiming): void;
4322 declare var AnimationEffect: {
4323 prototype: AnimationEffect;
4324 new(): AnimationEffect;
4325 isInstance: IsInstance<AnimationEffect>;
4328 interface AnimationEvent extends Event {
4329 readonly animationName: string;
4330 readonly elapsedTime: number;
4331 readonly pseudoElement: string;
4334 declare var AnimationEvent: {
4335 prototype: AnimationEvent;
4336 new(type: string, eventInitDict?: AnimationEventInit): AnimationEvent;
4337 isInstance: IsInstance<AnimationEvent>;
4340 interface AnimationFrameProvider {
4341 cancelAnimationFrame(handle: number): void;
4342 requestAnimationFrame(callback: FrameRequestCallback): number;
4345 interface AnimationPlaybackEvent extends Event {
4346 readonly currentTime: number | null;
4347 readonly timelineTime: number | null;
4350 declare var AnimationPlaybackEvent: {
4351 prototype: AnimationPlaybackEvent;
4352 new(type: string, eventInitDict?: AnimationPlaybackEventInit): AnimationPlaybackEvent;
4353 isInstance: IsInstance<AnimationPlaybackEvent>;
4356 interface AnimationTimeline {
4357 readonly currentTime: number | null;
4360 declare var AnimationTimeline: {
4361 prototype: AnimationTimeline;
4362 new(): AnimationTimeline;
4363 isInstance: IsInstance<AnimationTimeline>;
4366 interface AnonymousContent {
4367 readonly root: ShadowRoot;
4370 declare var AnonymousContent: {
4371 prototype: AnonymousContent;
4372 new(): AnonymousContent;
4373 isInstance: IsInstance<AnonymousContent>;
4376 interface Attr extends Node {
4377 readonly localName: string;
4378 readonly name: string;
4379 readonly namespaceURI: string | null;
4380 readonly ownerElement: Element | null;
4381 readonly prefix: string | null;
4382 readonly specified: boolean;
4389 isInstance: IsInstance<Attr>;
4392 interface AudioBuffer {
4393 readonly duration: number;
4394 readonly length: number;
4395 readonly numberOfChannels: number;
4396 readonly sampleRate: number;
4397 copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void;
4398 copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void;
4399 getChannelData(channel: number): Float32Array;
4402 declare var AudioBuffer: {
4403 prototype: AudioBuffer;
4404 new(options: AudioBufferOptions): AudioBuffer;
4405 isInstance: IsInstance<AudioBuffer>;
4408 interface AudioBufferSourceNode extends AudioScheduledSourceNode, AudioNodePassThrough {
4409 buffer: AudioBuffer | null;
4410 readonly detune: AudioParam;
4414 readonly playbackRate: AudioParam;
4415 start(when?: number, grainOffset?: number, grainDuration?: number): void;
4416 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4417 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4418 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioBufferSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4419 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4422 declare var AudioBufferSourceNode: {
4423 prototype: AudioBufferSourceNode;
4424 new(context: BaseAudioContext, options?: AudioBufferSourceOptions): AudioBufferSourceNode;
4425 isInstance: IsInstance<AudioBufferSourceNode>;
4428 interface AudioContext extends BaseAudioContext {
4429 readonly baseLatency: number;
4430 readonly outputLatency: number;
4431 close(): Promise<void>;
4432 createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
4433 createMediaStreamDestination(): MediaStreamAudioDestinationNode;
4434 createMediaStreamSource(mediaStream: MediaStream): MediaStreamAudioSourceNode;
4435 createMediaStreamTrackSource(mediaStreamTrack: MediaStreamTrack): MediaStreamTrackAudioSourceNode;
4436 getOutputTimestamp(): AudioTimestamp;
4437 suspend(): Promise<void>;
4438 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4439 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4440 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: AudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4441 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4444 declare var AudioContext: {
4445 prototype: AudioContext;
4446 new(contextOptions?: AudioContextOptions): AudioContext;
4447 isInstance: IsInstance<AudioContext>;
4450 interface AudioData {
4451 readonly duration: number;
4452 readonly format: AudioSampleFormat | null;
4453 readonly numberOfChannels: number;
4454 readonly numberOfFrames: number;
4455 readonly sampleRate: number;
4456 readonly timestamp: number;
4457 allocationSize(options: AudioDataCopyToOptions): number;
4460 copyTo(destination: ArrayBufferView | ArrayBuffer, options: AudioDataCopyToOptions): void;
4463 declare var AudioData: {
4464 prototype: AudioData;
4465 new(init: AudioDataInit): AudioData;
4466 isInstance: IsInstance<AudioData>;
4469 interface AudioDecoderEventMap {
4473 /** Available only in secure contexts. */
4474 interface AudioDecoder extends EventTarget {
4475 readonly decodeQueueSize: number;
4476 ondequeue: ((this: AudioDecoder, ev: Event) => any) | null;
4477 readonly state: CodecState;
4479 configure(config: AudioDecoderConfig): void;
4480 decode(chunk: EncodedAudioChunk): void;
4481 flush(): Promise<void>;
4483 addEventListener<K extends keyof AudioDecoderEventMap>(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4484 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4485 removeEventListener<K extends keyof AudioDecoderEventMap>(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4486 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4489 declare var AudioDecoder: {
4490 prototype: AudioDecoder;
4491 new(init: AudioDecoderInit): AudioDecoder;
4492 isInstance: IsInstance<AudioDecoder>;
4493 isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>;
4496 interface AudioDestinationNode extends AudioNode {
4497 readonly maxChannelCount: number;
4500 declare var AudioDestinationNode: {
4501 prototype: AudioDestinationNode;
4502 new(): AudioDestinationNode;
4503 isInstance: IsInstance<AudioDestinationNode>;
4506 interface AudioEncoderEventMap {
4510 /** Available only in secure contexts. */
4511 interface AudioEncoder extends EventTarget {
4512 readonly encodeQueueSize: number;
4513 ondequeue: ((this: AudioEncoder, ev: Event) => any) | null;
4514 readonly state: CodecState;
4516 configure(config: AudioEncoderConfig): void;
4517 encode(data: AudioData): void;
4518 flush(): Promise<void>;
4520 addEventListener<K extends keyof AudioEncoderEventMap>(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4521 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4522 removeEventListener<K extends keyof AudioEncoderEventMap>(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4523 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4526 declare var AudioEncoder: {
4527 prototype: AudioEncoder;
4528 new(init: AudioEncoderInit): AudioEncoder;
4529 isInstance: IsInstance<AudioEncoder>;
4530 isConfigSupported(config: AudioEncoderConfig): Promise<AudioEncoderSupport>;
4533 interface AudioListener {
4534 setOrientation(x: number, y: number, z: number, xUp: number, yUp: number, zUp: number): void;
4535 setPosition(x: number, y: number, z: number): void;
4538 declare var AudioListener: {
4539 prototype: AudioListener;
4540 new(): AudioListener;
4541 isInstance: IsInstance<AudioListener>;
4544 interface AudioNode extends EventTarget {
4545 channelCount: number;
4546 channelCountMode: ChannelCountMode;
4547 channelInterpretation: ChannelInterpretation;
4548 readonly context: BaseAudioContext;
4549 readonly id: number;
4550 readonly numberOfInputs: number;
4551 readonly numberOfOutputs: number;
4552 connect(destination: AudioNode, output?: number, input?: number): AudioNode;
4553 connect(destination: AudioParam, output?: number): void;
4555 disconnect(output: number): void;
4556 disconnect(destination: AudioNode): void;
4557 disconnect(destination: AudioNode, output: number): void;
4558 disconnect(destination: AudioNode, output: number, input: number): void;
4559 disconnect(destination: AudioParam): void;
4560 disconnect(destination: AudioParam, output: number): void;
4563 declare var AudioNode: {
4564 prototype: AudioNode;
4566 isInstance: IsInstance<AudioNode>;
4569 interface AudioNodePassThrough {
4570 passThrough: boolean;
4573 interface AudioParam {
4574 readonly defaultValue: number;
4575 readonly isTrackSuspended: boolean;
4576 readonly maxValue: number;
4577 readonly minValue: number;
4578 readonly name: string;
4579 readonly parentNodeId: number;
4581 cancelScheduledValues(startTime: number): AudioParam;
4582 exponentialRampToValueAtTime(value: number, endTime: number): AudioParam;
4583 linearRampToValueAtTime(value: number, endTime: number): AudioParam;
4584 setTargetAtTime(target: number, startTime: number, timeConstant: number): AudioParam;
4585 setValueAtTime(value: number, startTime: number): AudioParam;
4586 setValueCurveAtTime(values: number[] | Float32Array, startTime: number, duration: number): AudioParam;
4589 declare var AudioParam: {
4590 prototype: AudioParam;
4592 isInstance: IsInstance<AudioParam>;
4595 /** Available only in secure contexts. */
4596 interface AudioParamMap {
4597 forEach(callbackfn: (value: AudioParam, key: string, parent: AudioParamMap) => void, thisArg?: any): void;
4600 declare var AudioParamMap: {
4601 prototype: AudioParamMap;
4602 new(): AudioParamMap;
4603 isInstance: IsInstance<AudioParamMap>;
4606 interface AudioProcessingEvent extends Event {
4607 readonly inputBuffer: AudioBuffer;
4608 readonly outputBuffer: AudioBuffer;
4609 readonly playbackTime: number;
4612 declare var AudioProcessingEvent: {
4613 prototype: AudioProcessingEvent;
4614 new(): AudioProcessingEvent;
4615 isInstance: IsInstance<AudioProcessingEvent>;
4618 interface AudioScheduledSourceNodeEventMap {
4622 interface AudioScheduledSourceNode extends AudioNode {
4623 onended: ((this: AudioScheduledSourceNode, ev: Event) => any) | null;
4624 start(when?: number): void;
4625 stop(when?: number): void;
4626 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4627 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4628 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: AudioScheduledSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4629 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4632 declare var AudioScheduledSourceNode: {
4633 prototype: AudioScheduledSourceNode;
4634 new(): AudioScheduledSourceNode;
4635 isInstance: IsInstance<AudioScheduledSourceNode>;
4638 interface AudioTrack {
4640 readonly id: string;
4641 readonly kind: string;
4642 readonly label: string;
4643 readonly language: string;
4646 declare var AudioTrack: {
4647 prototype: AudioTrack;
4649 isInstance: IsInstance<AudioTrack>;
4652 interface AudioTrackListEventMap {
4655 "removetrack": Event;
4658 interface AudioTrackList extends EventTarget {
4659 readonly length: number;
4660 onaddtrack: ((this: AudioTrackList, ev: Event) => any) | null;
4661 onchange: ((this: AudioTrackList, ev: Event) => any) | null;
4662 onremovetrack: ((this: AudioTrackList, ev: Event) => any) | null;
4663 getTrackById(id: string): AudioTrack | null;
4664 addEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4665 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4666 removeEventListener<K extends keyof AudioTrackListEventMap>(type: K, listener: (this: AudioTrackList, ev: AudioTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4667 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4668 [index: number]: AudioTrack;
4671 declare var AudioTrackList: {
4672 prototype: AudioTrackList;
4673 new(): AudioTrackList;
4674 isInstance: IsInstance<AudioTrackList>;
4677 /** Available only in secure contexts. */
4678 interface AudioWorklet extends Worklet {
4681 declare var AudioWorklet: {
4682 prototype: AudioWorklet;
4683 new(): AudioWorklet;
4684 isInstance: IsInstance<AudioWorklet>;
4687 interface AudioWorkletNodeEventMap {
4688 "processorerror": Event;
4691 /** Available only in secure contexts. */
4692 interface AudioWorkletNode extends AudioNode {
4693 onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null;
4694 readonly parameters: AudioParamMap;
4695 readonly port: MessagePort;
4696 addEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4697 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4698 removeEventListener<K extends keyof AudioWorkletNodeEventMap>(type: K, listener: (this: AudioWorkletNode, ev: AudioWorkletNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4699 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4702 declare var AudioWorkletNode: {
4703 prototype: AudioWorkletNode;
4704 new(context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions): AudioWorkletNode;
4705 isInstance: IsInstance<AudioWorkletNode>;
4708 /** Available only in secure contexts. */
4709 interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
4710 readonly authenticatorData: ArrayBuffer;
4711 readonly signature: ArrayBuffer;
4712 readonly userHandle: ArrayBuffer | null;
4715 declare var AuthenticatorAssertionResponse: {
4716 prototype: AuthenticatorAssertionResponse;
4717 new(): AuthenticatorAssertionResponse;
4718 isInstance: IsInstance<AuthenticatorAssertionResponse>;
4721 /** Available only in secure contexts. */
4722 interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
4723 readonly attestationObject: ArrayBuffer;
4724 getAuthenticatorData(): ArrayBuffer;
4725 getPublicKey(): ArrayBuffer | null;
4726 getPublicKeyAlgorithm(): COSEAlgorithmIdentifier;
4727 getTransports(): string[];
4730 declare var AuthenticatorAttestationResponse: {
4731 prototype: AuthenticatorAttestationResponse;
4732 new(): AuthenticatorAttestationResponse;
4733 isInstance: IsInstance<AuthenticatorAttestationResponse>;
4736 /** Available only in secure contexts. */
4737 interface AuthenticatorResponse {
4738 readonly clientDataJSON: ArrayBuffer;
4741 declare var AuthenticatorResponse: {
4742 prototype: AuthenticatorResponse;
4743 new(): AuthenticatorResponse;
4744 isInstance: IsInstance<AuthenticatorResponse>;
4751 declare var BarProp: {
4754 isInstance: IsInstance<BarProp>;
4757 interface BaseAudioContextEventMap {
4758 "statechange": Event;
4761 interface BaseAudioContext extends EventTarget {
4762 /** Available only in secure contexts. */
4763 readonly audioWorklet: AudioWorklet;
4764 readonly currentTime: number;
4765 readonly destination: AudioDestinationNode;
4766 readonly listener: AudioListener;
4767 onstatechange: ((this: BaseAudioContext, ev: Event) => any) | null;
4768 readonly sampleRate: number;
4769 readonly state: AudioContextState;
4770 createAnalyser(): AnalyserNode;
4771 createBiquadFilter(): BiquadFilterNode;
4772 createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
4773 createBufferSource(): AudioBufferSourceNode;
4774 createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
4775 createChannelSplitter(numberOfOutputs?: number): ChannelSplitterNode;
4776 createConstantSource(): ConstantSourceNode;
4777 createConvolver(): ConvolverNode;
4778 createDelay(maxDelayTime?: number): DelayNode;
4779 createDynamicsCompressor(): DynamicsCompressorNode;
4780 createGain(): GainNode;
4781 createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
4782 createOscillator(): OscillatorNode;
4783 createPanner(): PannerNode;
4784 createPeriodicWave(real: number[] | Float32Array, imag: number[] | Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
4785 createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
4786 createStereoPanner(): StereoPannerNode;
4787 createWaveShaper(): WaveShaperNode;
4788 decodeAudioData(audioData: ArrayBuffer, successCallback?: DecodeSuccessCallback, errorCallback?: DecodeErrorCallback): Promise<AudioBuffer>;
4789 resume(): Promise<void>;
4790 addEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4791 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4792 removeEventListener<K extends keyof BaseAudioContextEventMap>(type: K, listener: (this: BaseAudioContext, ev: BaseAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4793 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4796 declare var BaseAudioContext: {
4797 prototype: BaseAudioContext;
4798 new(): BaseAudioContext;
4799 isInstance: IsInstance<BaseAudioContext>;
4802 interface BatteryManagerEventMap {
4803 "chargingchange": Event;
4804 "chargingtimechange": Event;
4805 "dischargingtimechange": Event;
4806 "levelchange": Event;
4809 interface BatteryManager extends EventTarget {
4810 readonly charging: boolean;
4811 readonly chargingTime: number;
4812 readonly dischargingTime: number;
4813 readonly level: number;
4814 onchargingchange: ((this: BatteryManager, ev: Event) => any) | null;
4815 onchargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
4816 ondischargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
4817 onlevelchange: ((this: BatteryManager, ev: Event) => any) | null;
4818 addEventListener<K extends keyof BatteryManagerEventMap>(type: K, listener: (this: BatteryManager, ev: BatteryManagerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4819 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4820 removeEventListener<K extends keyof BatteryManagerEventMap>(type: K, listener: (this: BatteryManager, ev: BatteryManagerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4821 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4824 declare var BatteryManager: {
4825 prototype: BatteryManager;
4826 new(): BatteryManager;
4827 isInstance: IsInstance<BatteryManager>;
4831 interface BeforeUnloadEvent extends Event {
4832 returnValue: string;
4835 declare var BeforeUnloadEvent: {
4836 prototype: BeforeUnloadEvent;
4837 new(): BeforeUnloadEvent;
4838 isInstance: IsInstance<BeforeUnloadEvent>;
4841 interface BiquadFilterNode extends AudioNode, AudioNodePassThrough {
4842 readonly Q: AudioParam;
4843 readonly detune: AudioParam;
4844 readonly frequency: AudioParam;
4845 readonly gain: AudioParam;
4846 type: BiquadFilterType;
4847 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
4850 declare var BiquadFilterNode: {
4851 prototype: BiquadFilterNode;
4852 new(context: BaseAudioContext, options?: BiquadFilterOptions): BiquadFilterNode;
4853 isInstance: IsInstance<BiquadFilterNode>;
4857 readonly blobImplType: string;
4858 readonly size: number;
4859 readonly type: string;
4860 arrayBuffer(): Promise<ArrayBuffer>;
4861 bytes(): Promise<Uint8Array>;
4862 slice(start?: number, end?: number, contentType?: string): Blob;
4863 stream(): ReadableStream;
4864 text(): Promise<string>;
4869 new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
4870 isInstance: IsInstance<Blob>;
4873 interface BlobEvent extends Event {
4874 readonly data: Blob;
4877 declare var BlobEvent: {
4878 prototype: BlobEvent;
4879 new(type: string, eventInitDict: BlobEventInit): BlobEvent;
4880 isInstance: IsInstance<BlobEvent>;
4884 readonly bodyUsed: boolean;
4885 arrayBuffer(): Promise<ArrayBuffer>;
4886 blob(): Promise<Blob>;
4887 bytes(): Promise<Uint8Array>;
4888 formData(): Promise<FormData>;
4889 json(): Promise<JSON>;
4890 text(): Promise<string>;
4893 interface BroadcastChannelEventMap {
4895 "messageerror": Event;
4898 interface BroadcastChannel extends EventTarget {
4899 readonly name: string;
4900 onmessage: ((this: BroadcastChannel, ev: Event) => any) | null;
4901 onmessageerror: ((this: BroadcastChannel, ev: Event) => any) | null;
4903 postMessage(message: any): void;
4904 addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
4905 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
4906 removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
4907 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
4910 declare var BroadcastChannel: {
4911 prototype: BroadcastChannel;
4912 new(channel: string): BroadcastChannel;
4913 isInstance: IsInstance<BroadcastChannel>;
4916 interface BrowsingContext extends LoadContextMixin {
4917 allowJavascript: boolean;
4918 readonly ancestorsAreCurrent: boolean;
4919 authorStyleDisabledDefault: boolean;
4921 readonly childOffset: number;
4922 readonly childSessionHistory: ChildSHistory | null;
4923 readonly children: BrowsingContext[];
4924 readonly createdDynamically: boolean;
4925 readonly currentWindowContext: WindowContext | null;
4926 customPlatform: string;
4927 customUserAgent: string;
4928 defaultLoadFlags: number;
4929 displayMode: DisplayMode;
4930 readonly docShell: nsIDocShell | null;
4931 readonly embedderElement: Element | null;
4932 readonly embedderElementType: string;
4933 forceDesktopViewport: boolean;
4934 forceOffline: boolean;
4936 readonly group: BrowsingContextGroup;
4937 hasSiblings: boolean;
4938 readonly historyID: any;
4939 readonly id: number;
4941 readonly isActive: boolean;
4943 readonly isDiscarded: boolean;
4944 readonly isInBFCache: boolean;
4945 mediumOverride: string;
4946 readonly name: string;
4947 readonly opener: BrowsingContext | null;
4948 overrideDPPX: number;
4949 readonly parent: BrowsingContext | null;
4950 readonly parentWindowContext: WindowContext | null;
4951 prefersColorSchemeOverride: PrefersColorSchemeOverride;
4952 sandboxFlags: number;
4953 serviceWorkersTestingEnabled: boolean;
4954 suspendMediaWhenInactive: boolean;
4955 readonly targetTopLevelLinkClicksToBlank: boolean;
4957 readonly top: BrowsingContext;
4958 readonly topWindowContext: WindowContext | null;
4959 readonly touchEventsOverride: TouchEventsOverride;
4960 useGlobalHistory: boolean;
4961 watchedByDevTools: boolean;
4962 readonly window: WindowProxy | null;
4963 getAllBrowsingContextsInSubtree(): BrowsingContext[];
4964 resetLocationChangeRateLimit(): void;
4965 setRDMPaneMaxTouchPoints(maxTouchPoints: number): void;
4966 setRDMPaneOrientation(type: OrientationType, rotationAngle: number): void;
4969 declare var BrowsingContext: {
4970 prototype: BrowsingContext;
4971 new(): BrowsingContext;
4972 isInstance: IsInstance<BrowsingContext>;
4973 get(aId: number): BrowsingContext | null;
4974 getCurrentTopByBrowserId(aId: number): BrowsingContext | null;
4975 getFromWindow(window: WindowProxy): BrowsingContext | null;
4978 interface BrowsingContextGroup {
4979 readonly id: number;
4980 getToplevels(): BrowsingContext[];
4983 declare var BrowsingContextGroup: {
4984 prototype: BrowsingContextGroup;
4985 new(): BrowsingContextGroup;
4986 isInstance: IsInstance<BrowsingContextGroup>;
4989 interface BufferSource {
4992 interface ByteLengthQueuingStrategy {
4993 readonly highWaterMark: number;
4994 readonly size: Function;
4997 declare var ByteLengthQueuingStrategy: {
4998 prototype: ByteLengthQueuingStrategy;
4999 new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;
5000 isInstance: IsInstance<ByteLengthQueuingStrategy>;
5003 interface CDATASection extends Text {
5006 declare var CDATASection: {
5007 prototype: CDATASection;
5008 new(): CDATASection;
5009 isInstance: IsInstance<CDATASection>;
5012 interface CSSAnimation extends Animation {
5013 readonly animationName: string;
5014 addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5015 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5016 removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSAnimation, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5017 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5020 declare var CSSAnimation: {
5021 prototype: CSSAnimation;
5022 new(): CSSAnimation;
5023 isInstance: IsInstance<CSSAnimation>;
5026 interface CSSConditionRule extends CSSGroupingRule {
5027 readonly conditionText: string;
5030 declare var CSSConditionRule: {
5031 prototype: CSSConditionRule;
5032 new(): CSSConditionRule;
5033 isInstance: IsInstance<CSSConditionRule>;
5036 interface CSSContainerRule extends CSSConditionRule {
5037 readonly containerName: string;
5038 readonly containerQuery: string;
5039 queryContainerFor(element: Element): Element | null;
5042 declare var CSSContainerRule: {
5043 prototype: CSSContainerRule;
5044 new(): CSSContainerRule;
5045 isInstance: IsInstance<CSSContainerRule>;
5048 interface CSSCounterStyleRule extends CSSRule {
5049 additiveSymbols: string;
5062 declare var CSSCounterStyleRule: {
5063 prototype: CSSCounterStyleRule;
5064 new(): CSSCounterStyleRule;
5065 isInstance: IsInstance<CSSCounterStyleRule>;
5068 interface CSSCustomPropertyRegisteredEvent extends Event {
5069 readonly propertyDefinition: InspectorCSSPropertyDefinition;
5072 declare var CSSCustomPropertyRegisteredEvent: {
5073 prototype: CSSCustomPropertyRegisteredEvent;
5074 new(type: string, eventInitDict?: CSSCustomPropertyRegisteredEventInit): CSSCustomPropertyRegisteredEvent;
5075 isInstance: IsInstance<CSSCustomPropertyRegisteredEvent>;
5078 interface CSSFontFaceRule extends CSSRule {
5079 readonly style: CSSStyleDeclaration;
5082 declare var CSSFontFaceRule: {
5083 prototype: CSSFontFaceRule;
5084 new(): CSSFontFaceRule;
5085 isInstance: IsInstance<CSSFontFaceRule>;
5088 interface CSSFontFeatureValuesRule extends CSSRule {
5093 declare var CSSFontFeatureValuesRule: {
5094 prototype: CSSFontFeatureValuesRule;
5095 new(): CSSFontFeatureValuesRule;
5096 isInstance: IsInstance<CSSFontFeatureValuesRule>;
5099 interface CSSFontPaletteValuesRule extends CSSRule {
5100 readonly basePalette: string;
5101 readonly fontFamily: string;
5102 readonly name: string;
5103 readonly overrideColors: string;
5106 declare var CSSFontPaletteValuesRule: {
5107 prototype: CSSFontPaletteValuesRule;
5108 new(): CSSFontPaletteValuesRule;
5109 isInstance: IsInstance<CSSFontPaletteValuesRule>;
5112 interface CSSGroupingRule extends CSSRule {
5113 readonly cssRules: CSSRuleList;
5114 deleteRule(index: number): void;
5115 insertRule(rule: string, index?: number): number;
5118 declare var CSSGroupingRule: {
5119 prototype: CSSGroupingRule;
5120 new(): CSSGroupingRule;
5121 isInstance: IsInstance<CSSGroupingRule>;
5124 interface CSSImportRule extends CSSRule {
5125 readonly href: string;
5126 readonly layerName: string | null;
5127 readonly media: MediaList | null;
5128 readonly styleSheet: CSSStyleSheet | null;
5129 readonly supportsText: string | null;
5132 declare var CSSImportRule: {
5133 prototype: CSSImportRule;
5134 new(): CSSImportRule;
5135 isInstance: IsInstance<CSSImportRule>;
5138 interface CSSKeyframeRule extends CSSRule {
5140 readonly style: CSSStyleDeclaration;
5143 declare var CSSKeyframeRule: {
5144 prototype: CSSKeyframeRule;
5145 new(): CSSKeyframeRule;
5146 isInstance: IsInstance<CSSKeyframeRule>;
5149 interface CSSKeyframesRule extends CSSRule {
5150 readonly cssRules: CSSRuleList;
5151 readonly length: number;
5153 appendRule(rule: string): void;
5154 deleteRule(select: string): void;
5155 findRule(select: string): CSSKeyframeRule | null;
5156 [index: number]: CSSKeyframeRule;
5159 declare var CSSKeyframesRule: {
5160 prototype: CSSKeyframesRule;
5161 new(): CSSKeyframesRule;
5162 isInstance: IsInstance<CSSKeyframesRule>;
5165 interface CSSLayerBlockRule extends CSSGroupingRule {
5166 readonly name: string;
5169 declare var CSSLayerBlockRule: {
5170 prototype: CSSLayerBlockRule;
5171 new(): CSSLayerBlockRule;
5172 isInstance: IsInstance<CSSLayerBlockRule>;
5175 interface CSSLayerStatementRule extends CSSRule {
5176 readonly nameList: string[];
5179 declare var CSSLayerStatementRule: {
5180 prototype: CSSLayerStatementRule;
5181 new(): CSSLayerStatementRule;
5182 isInstance: IsInstance<CSSLayerStatementRule>;
5185 interface CSSMarginRule extends CSSRule {
5186 readonly name: string;
5187 readonly style: CSSStyleDeclaration;
5190 declare var CSSMarginRule: {
5191 prototype: CSSMarginRule;
5192 new(): CSSMarginRule;
5193 isInstance: IsInstance<CSSMarginRule>;
5196 interface CSSMediaRule extends CSSConditionRule {
5197 readonly media: MediaList;
5200 declare var CSSMediaRule: {
5201 prototype: CSSMediaRule;
5202 new(): CSSMediaRule;
5203 isInstance: IsInstance<CSSMediaRule>;
5206 interface CSSMozDocumentRule extends CSSConditionRule {
5209 declare var CSSMozDocumentRule: {
5210 prototype: CSSMozDocumentRule;
5211 new(): CSSMozDocumentRule;
5212 isInstance: IsInstance<CSSMozDocumentRule>;
5215 interface CSSNamespaceRule extends CSSRule {
5216 readonly namespaceURI: string;
5217 readonly prefix: string;
5220 declare var CSSNamespaceRule: {
5221 prototype: CSSNamespaceRule;
5222 new(): CSSNamespaceRule;
5223 isInstance: IsInstance<CSSNamespaceRule>;
5226 interface CSSPageRule extends CSSGroupingRule {
5227 selectorText: string;
5228 readonly style: CSSStyleDeclaration;
5231 declare var CSSPageRule: {
5232 prototype: CSSPageRule;
5234 isInstance: IsInstance<CSSPageRule>;
5237 interface CSSPropertyRule extends CSSRule {
5238 readonly inherits: boolean;
5239 readonly initialValue: string | null;
5240 readonly name: string;
5241 readonly syntax: string;
5244 declare var CSSPropertyRule: {
5245 prototype: CSSPropertyRule;
5246 new(): CSSPropertyRule;
5247 isInstance: IsInstance<CSSPropertyRule>;
5250 interface CSSPseudoElement {
5251 readonly element: Element;
5252 readonly type: string;
5255 declare var CSSPseudoElement: {
5256 prototype: CSSPseudoElement;
5257 new(): CSSPseudoElement;
5258 isInstance: IsInstance<CSSPseudoElement>;
5263 readonly parentRule: CSSRule | null;
5264 readonly parentStyleSheet: CSSStyleSheet | null;
5265 readonly type: number;
5266 readonly STYLE_RULE: 1;
5267 readonly CHARSET_RULE: 2;
5268 readonly IMPORT_RULE: 3;
5269 readonly MEDIA_RULE: 4;
5270 readonly FONT_FACE_RULE: 5;
5271 readonly PAGE_RULE: 6;
5272 readonly NAMESPACE_RULE: 10;
5273 readonly KEYFRAMES_RULE: 7;
5274 readonly KEYFRAME_RULE: 8;
5275 readonly COUNTER_STYLE_RULE: 11;
5276 readonly SUPPORTS_RULE: 12;
5277 readonly DOCUMENT_RULE: 13;
5278 readonly FONT_FEATURE_VALUES_RULE: 14;
5281 declare var CSSRule: {
5284 readonly STYLE_RULE: 1;
5285 readonly CHARSET_RULE: 2;
5286 readonly IMPORT_RULE: 3;
5287 readonly MEDIA_RULE: 4;
5288 readonly FONT_FACE_RULE: 5;
5289 readonly PAGE_RULE: 6;
5290 readonly NAMESPACE_RULE: 10;
5291 readonly KEYFRAMES_RULE: 7;
5292 readonly KEYFRAME_RULE: 8;
5293 readonly COUNTER_STYLE_RULE: 11;
5294 readonly SUPPORTS_RULE: 12;
5295 readonly DOCUMENT_RULE: 13;
5296 readonly FONT_FEATURE_VALUES_RULE: 14;
5297 isInstance: IsInstance<CSSRule>;
5300 interface CSSRuleList {
5301 readonly length: number;
5302 item(index: number): CSSRule | null;
5303 [index: number]: CSSRule;
5306 declare var CSSRuleList: {
5307 prototype: CSSRuleList;
5309 isInstance: IsInstance<CSSRuleList>;
5312 interface CSSScopeRule extends CSSGroupingRule {
5313 readonly end: string | null;
5314 readonly start: string | null;
5317 declare var CSSScopeRule: {
5318 prototype: CSSScopeRule;
5319 new(): CSSScopeRule;
5320 isInstance: IsInstance<CSSScopeRule>;
5323 interface CSSStartingStyleRule extends CSSGroupingRule {
5326 declare var CSSStartingStyleRule: {
5327 prototype: CSSStartingStyleRule;
5328 new(): CSSStartingStyleRule;
5329 isInstance: IsInstance<CSSStartingStyleRule>;
5332 interface CSSStyleDeclaration {
5334 readonly length: number;
5335 readonly parentRule: CSSRule | null;
5336 readonly usedFontSize: number;
5337 getCSSImageURLs(property: string): string[];
5338 getPropertyPriority(property: string): string;
5339 getPropertyValue(property: string): string;
5340 item(index: number): string;
5341 removeProperty(property: string): string;
5342 setProperty(property: string, value: string | null, priority?: string): void;
5343 [index: number]: string;
5346 declare var CSSStyleDeclaration: {
5347 prototype: CSSStyleDeclaration;
5348 new(): CSSStyleDeclaration;
5349 isInstance: IsInstance<CSSStyleDeclaration>;
5352 interface CSSStyleRule extends CSSGroupingRule {
5353 readonly selectorCount: number;
5354 selectorText: string;
5355 readonly style: CSSStyleDeclaration;
5356 getSelectorWarnings(): SelectorWarning[];
5357 selectorMatchesElement(selectorIndex: number, element: Element, pseudo?: string, includeVisitedStyle?: boolean): boolean;
5358 selectorSpecificityAt(index: number, desugared?: boolean): number;
5359 selectorTextAt(index: number, desugared?: boolean): string;
5362 declare var CSSStyleRule: {
5363 prototype: CSSStyleRule;
5364 new(): CSSStyleRule;
5365 isInstance: IsInstance<CSSStyleRule>;
5368 interface CSSStyleSheet extends StyleSheet {
5369 readonly cssRules: CSSRuleList;
5370 readonly ownerRule: CSSRule | null;
5371 readonly parsingMode: CSSStyleSheetParsingMode;
5372 readonly rules: CSSRuleList;
5373 addRule(selector?: string, style?: string, index?: number): number;
5374 deleteRule(index: number): void;
5375 insertRule(rule: string, index?: number): number;
5376 removeRule(index?: number): void;
5377 replace(text: string): Promise<CSSStyleSheet>;
5378 replaceSync(text: string): void;
5381 declare var CSSStyleSheet: {
5382 prototype: CSSStyleSheet;
5383 new(options?: CSSStyleSheetInit): CSSStyleSheet;
5384 isInstance: IsInstance<CSSStyleSheet>;
5387 interface CSSSupportsRule extends CSSConditionRule {
5390 declare var CSSSupportsRule: {
5391 prototype: CSSSupportsRule;
5392 new(): CSSSupportsRule;
5393 isInstance: IsInstance<CSSSupportsRule>;
5396 interface CSSTransition extends Animation {
5397 readonly transitionProperty: string;
5398 addEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5399 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5400 removeEventListener<K extends keyof AnimationEventMap>(type: K, listener: (this: CSSTransition, ev: AnimationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5401 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5404 declare var CSSTransition: {
5405 prototype: CSSTransition;
5406 new(): CSSTransition;
5407 isInstance: IsInstance<CSSTransition>;
5411 add(request: RequestInfo | URL): Promise<void>;
5412 addAll(requests: RequestInfo[]): Promise<void>;
5413 delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
5414 keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<Request[]>;
5415 match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response>;
5416 matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response[]>;
5417 put(request: RequestInfo | URL, response: Response): Promise<void>;
5420 declare var Cache: {
5423 isInstance: IsInstance<Cache>;
5426 interface CacheStorage {
5427 delete(cacheName: string): Promise<boolean>;
5428 has(cacheName: string): Promise<boolean>;
5429 keys(): Promise<string[]>;
5430 match(request: RequestInfo | URL, options?: MultiCacheQueryOptions): Promise<Response>;
5431 open(cacheName: string): Promise<Cache>;
5434 declare var CacheStorage: {
5435 prototype: CacheStorage;
5436 new(namespace: CacheStorageNamespace, principal: Principal): CacheStorage;
5437 isInstance: IsInstance<CacheStorage>;
5440 interface CallbackDebuggerNotification extends DebuggerNotification {
5441 readonly phase: CallbackDebuggerNotificationPhase;
5444 declare var CallbackDebuggerNotification: {
5445 prototype: CallbackDebuggerNotification;
5446 new(): CallbackDebuggerNotification;
5447 isInstance: IsInstance<CallbackDebuggerNotification>;
5450 interface CanonicalBrowsingContext extends BrowsingContext {
5451 readonly activeSessionHistoryEntry: nsISHEntry | null;
5452 readonly currentRemoteType: string | null;
5453 readonly currentURI: URI | null;
5454 readonly currentWindowGlobal: WindowGlobalParent | null;
5455 readonly embedderWindowGlobal: WindowGlobalParent | null;
5456 forceAppWindowActive: boolean;
5458 readonly isReplaced: boolean;
5459 readonly isUnderHiddenEmbedderElement: boolean;
5460 readonly mediaController: MediaController | null;
5461 readonly mostRecentLoadingSessionHistoryEntry: nsISHEntry | null;
5462 readonly secureBrowserUI: nsISecureBrowserUI | null;
5463 readonly sessionHistory: nsISHistory | null;
5464 targetTopLevelLinkClicksToBlank: boolean;
5465 readonly topChromeWindow: WindowProxy | null;
5466 touchEventsOverride: TouchEventsOverride;
5467 readonly webProgress: nsIWebProgress | null;
5468 clearRestoreState(): void;
5469 fixupAndLoadURIString(aURI: string, aOptions?: LoadURIOptions): void;
5470 getWindowGlobals(): WindowGlobalParent[];
5471 goBack(aCancelContentJSEpoch?: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
5472 goForward(aCancelContentJSEpoch?: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
5473 goToIndex(aIndex: number, aCancelContentJSEpoch?: number, aUserActivation?: boolean): void;
5474 loadURI(aURI: URI, aOptions?: LoadURIOptions): void;
5475 notifyMediaMutedChanged(muted: boolean): void;
5476 notifyStartDelayedAutoplayMedia(): void;
5477 print(aPrintSettings: nsIPrintSettings): Promise<void>;
5478 reload(aReloadFlags: number): void;
5479 resetScalingZoom(): void;
5480 setCrossGroupOpener(crossGroupOpener: CanonicalBrowsingContext): void;
5481 startApzAutoscroll(aAnchorX: number, aAnchorY: number, aScrollId: number, aPresShellId: number): boolean;
5482 stop(aStopFlags: number): void;
5483 stopApzAutoscroll(aScrollId: number, aPresShellId: number): void;
5486 declare var CanonicalBrowsingContext: {
5487 prototype: CanonicalBrowsingContext;
5488 new(): CanonicalBrowsingContext;
5489 isInstance: IsInstance<CanonicalBrowsingContext>;
5490 countSiteOrigins(roots: BrowsingContext[]): number;
5493 interface CanvasCaptureMediaStream extends MediaStream {
5494 readonly canvas: HTMLCanvasElement;
5495 requestFrame(): void;
5496 addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: CanvasCaptureMediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5497 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5498 removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: CanvasCaptureMediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5499 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5502 declare var CanvasCaptureMediaStream: {
5503 prototype: CanvasCaptureMediaStream;
5504 new(): CanvasCaptureMediaStream;
5505 isInstance: IsInstance<CanvasCaptureMediaStream>;
5508 interface CanvasCompositing {
5509 globalAlpha: number;
5510 globalCompositeOperation: string;
5513 interface CanvasDrawImage {
5514 drawImage(image: CanvasImageSource, dx: number, dy: number): void;
5515 drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
5516 drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
5519 interface CanvasDrawPath {
5521 clip(winding?: CanvasWindingRule): void;
5522 clip(path: Path2D, winding?: CanvasWindingRule): void;
5523 fill(winding?: CanvasWindingRule): void;
5524 fill(path: Path2D, winding?: CanvasWindingRule): void;
5525 isPointInPath(x: number, y: number, winding?: CanvasWindingRule): boolean;
5526 isPointInPath(path: Path2D, x: number, y: number, winding?: CanvasWindingRule): boolean;
5527 isPointInStroke(x: number, y: number): boolean;
5528 isPointInStroke(path: Path2D, x: number, y: number): boolean;
5530 stroke(path: Path2D): void;
5533 interface CanvasFillStrokeStyles {
5534 fillStyle: string | CanvasGradient | CanvasPattern;
5535 strokeStyle: string | CanvasGradient | CanvasPattern;
5536 createConicGradient(angle: number, cx: number, cy: number): CanvasGradient;
5537 createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
5538 createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
5539 createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
5542 interface CanvasFilters {
5546 interface CanvasGradient {
5547 addColorStop(offset: number, color: string): void;
5550 declare var CanvasGradient: {
5551 prototype: CanvasGradient;
5552 new(): CanvasGradient;
5553 isInstance: IsInstance<CanvasGradient>;
5556 interface CanvasImageData {
5557 createImageData(sw: number, sh: number): ImageData;
5558 createImageData(imagedata: ImageData): ImageData;
5559 getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
5560 putImageData(imagedata: ImageData, dx: number, dy: number): void;
5561 putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
5564 interface CanvasImageSmoothing {
5565 imageSmoothingEnabled: boolean;
5568 interface CanvasPathDrawingStyles {
5569 lineCap: CanvasLineCap;
5570 lineDashOffset: number;
5571 lineJoin: CanvasLineJoin;
5574 getLineDash(): number[];
5575 setLineDash(segments: number[]): void;
5578 interface CanvasPathMethods {
5579 arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
5580 arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
5581 bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
5583 ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
5584 lineTo(x: number, y: number): void;
5585 moveTo(x: number, y: number): void;
5586 quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
5587 rect(x: number, y: number, w: number, h: number): void;
5588 roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void;
5591 interface CanvasPattern {
5592 setTransform(matrix?: DOMMatrix2DInit): void;
5595 declare var CanvasPattern: {
5596 prototype: CanvasPattern;
5597 new(): CanvasPattern;
5598 isInstance: IsInstance<CanvasPattern>;
5601 interface CanvasRect {
5602 clearRect(x: number, y: number, w: number, h: number): void;
5603 fillRect(x: number, y: number, w: number, h: number): void;
5604 strokeRect(x: number, y: number, w: number, h: number): void;
5607 interface CanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPathDrawingStyles, CanvasPathMethods, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
5608 readonly canvas: HTMLCanvasElement | null;
5610 drawWindow(window: Window, x: number, y: number, w: number, h: number, bgColor: string, flags?: number): void;
5611 getContextAttributes(): CanvasRenderingContext2DSettings;
5612 readonly DRAWWINDOW_DRAW_CARET: 0x01;
5613 readonly DRAWWINDOW_DO_NOT_FLUSH: 0x02;
5614 readonly DRAWWINDOW_DRAW_VIEW: 0x04;
5615 readonly DRAWWINDOW_USE_WIDGET_LAYERS: 0x08;
5616 readonly DRAWWINDOW_ASYNC_DECODE_IMAGES: 0x10;
5619 declare var CanvasRenderingContext2D: {
5620 prototype: CanvasRenderingContext2D;
5621 new(): CanvasRenderingContext2D;
5622 readonly DRAWWINDOW_DRAW_CARET: 0x01;
5623 readonly DRAWWINDOW_DO_NOT_FLUSH: 0x02;
5624 readonly DRAWWINDOW_DRAW_VIEW: 0x04;
5625 readonly DRAWWINDOW_USE_WIDGET_LAYERS: 0x08;
5626 readonly DRAWWINDOW_ASYNC_DECODE_IMAGES: 0x10;
5627 isInstance: IsInstance<CanvasRenderingContext2D>;
5630 interface CanvasShadowStyles {
5632 shadowColor: string;
5633 shadowOffsetX: number;
5634 shadowOffsetY: number;
5637 interface CanvasState {
5638 isContextLost(): boolean;
5644 interface CanvasText {
5645 fillText(text: string, x: number, y: number, maxWidth?: number): void;
5646 measureText(text: string): TextMetrics;
5647 strokeText(text: string, x: number, y: number, maxWidth?: number): void;
5650 interface CanvasTextDrawingStyles {
5651 direction: CanvasDirection;
5653 fontKerning: CanvasFontKerning;
5654 fontStretch: CanvasFontStretch;
5655 fontVariantCaps: CanvasFontVariantCaps;
5656 letterSpacing: string;
5657 textAlign: CanvasTextAlign;
5658 textBaseline: CanvasTextBaseline;
5659 textRendering: CanvasTextRendering;
5660 wordSpacing: string;
5663 interface CanvasTransform {
5664 getTransform(): DOMMatrix;
5665 resetTransform(): void;
5666 rotate(angle: number): void;
5667 scale(x: number, y: number): void;
5668 setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
5669 setTransform(transform?: DOMMatrix2DInit): void;
5670 transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
5671 translate(x: number, y: number): void;
5674 interface CanvasUserInterface {
5675 drawFocusIfNeeded(element: Element): void;
5678 interface CaretPosition {
5679 readonly offset: number;
5680 readonly offsetNode: Node | null;
5681 getClientRect(): DOMRect | null;
5684 declare var CaretPosition: {
5685 prototype: CaretPosition;
5686 new(): CaretPosition;
5687 isInstance: IsInstance<CaretPosition>;
5690 interface CaretStateChangedEvent extends Event {
5691 readonly boundingClientRect: DOMRectReadOnly | null;
5692 readonly caretVisible: boolean;
5693 readonly caretVisuallyVisible: boolean;
5694 readonly clientX: number;
5695 readonly clientY: number;
5696 readonly collapsed: boolean;
5697 readonly reason: CaretChangedReason;
5698 readonly selectedTextContent: string;
5699 readonly selectionEditable: boolean;
5700 readonly selectionVisible: boolean;
5703 declare var CaretStateChangedEvent: {
5704 prototype: CaretStateChangedEvent;
5705 new(type: string, eventInit?: CaretStateChangedEventInit): CaretStateChangedEvent;
5706 isInstance: IsInstance<CaretStateChangedEvent>;
5709 interface ChannelMergerNode extends AudioNode {
5712 declare var ChannelMergerNode: {
5713 prototype: ChannelMergerNode;
5714 new(context: BaseAudioContext, options?: ChannelMergerOptions): ChannelMergerNode;
5715 isInstance: IsInstance<ChannelMergerNode>;
5718 interface ChannelSplitterNode extends AudioNode {
5721 declare var ChannelSplitterNode: {
5722 prototype: ChannelSplitterNode;
5723 new(context: BaseAudioContext, options?: ChannelSplitterOptions): ChannelSplitterNode;
5724 isInstance: IsInstance<ChannelSplitterNode>;
5727 interface ChannelWrapperEventMap {
5733 interface ChannelWrapper extends EventTarget {
5734 readonly browserElement: nsISupports | null;
5735 readonly canModify: boolean;
5736 channel: MozChannel | null;
5737 contentType: string;
5738 readonly documentURI: URI | null;
5739 readonly documentURL: string | null;
5740 readonly errorString: string | null;
5741 readonly finalURI: URI;
5742 readonly finalURL: string;
5743 readonly frameAncestors: MozFrameAncestorInfo[] | null;
5744 readonly frameId: number;
5745 readonly id: number;
5746 readonly isServiceWorkerScript: boolean;
5747 readonly isSystemLoad: boolean;
5748 readonly loadInfo: LoadInfo | null;
5749 readonly method: string;
5750 onerror: ((this: ChannelWrapper, ev: Event) => any) | null;
5751 onstart: ((this: ChannelWrapper, ev: Event) => any) | null;
5752 onstop: ((this: ChannelWrapper, ev: Event) => any) | null;
5753 readonly originURI: URI | null;
5754 readonly originURL: string | null;
5755 readonly parentFrameId: number;
5756 readonly proxyInfo: MozProxyInfo | null;
5757 readonly remoteAddress: string | null;
5758 readonly requestSize: number;
5759 readonly responseSize: number;
5760 readonly statusCode: number;
5761 readonly statusLine: string;
5762 readonly suspended: boolean;
5763 readonly thirdParty: boolean;
5764 readonly type: MozContentPolicyType;
5765 readonly urlClassification: MozUrlClassification | null;
5766 cancel(result: number, reason?: number): void;
5768 getRequestHeader(header: string): string | null;
5769 getRequestHeaders(): MozHTTPHeader[];
5770 getResponseHeaders(): MozHTTPHeader[];
5771 matches(filter?: MozRequestFilter, extension?: WebExtensionPolicy | null, options?: MozRequestMatchOptions): boolean;
5772 redirectTo(url: URI): void;
5773 registerTraceableChannel(extension: WebExtensionPolicy, remoteTab: RemoteTab | null): void;
5775 setRequestHeader(header: string, value: string, merge?: boolean): void;
5776 setResponseHeader(header: string, value: string, merge?: boolean): void;
5777 suspend(profileMarkerText: string): void;
5778 upgradeToSecure(): void;
5779 addEventListener<K extends keyof ChannelWrapperEventMap>(type: K, listener: (this: ChannelWrapper, ev: ChannelWrapperEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5780 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5781 removeEventListener<K extends keyof ChannelWrapperEventMap>(type: K, listener: (this: ChannelWrapper, ev: ChannelWrapperEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5782 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5785 declare var ChannelWrapper: {
5786 prototype: ChannelWrapper;
5787 new(): ChannelWrapper;
5788 isInstance: IsInstance<ChannelWrapper>;
5789 get(channel: MozChannel): ChannelWrapper;
5790 getRegisteredChannel(aChannelId: number, extension: WebExtensionPolicy, remoteTab: RemoteTab | null): ChannelWrapper | null;
5793 interface CharacterData extends Node, ChildNode, NonDocumentTypeChildNode {
5795 readonly length: number;
5796 appendData(data: string): void;
5797 deleteData(offset: number, count: number): void;
5798 insertData(offset: number, data: string): void;
5799 replaceData(offset: number, count: number, data: string): void;
5800 substringData(offset: number, count: number): string;
5803 declare var CharacterData: {
5804 prototype: CharacterData;
5805 new(): CharacterData;
5806 isInstance: IsInstance<CharacterData>;
5809 interface CheckerboardReportService {
5810 flushActiveReports(): void;
5811 getReports(): CheckerboardReport[];
5812 isRecordingEnabled(): boolean;
5813 setRecordingEnabled(aEnabled: boolean): void;
5816 declare var CheckerboardReportService: {
5817 prototype: CheckerboardReportService;
5818 new(): CheckerboardReportService;
5819 isInstance: IsInstance<CheckerboardReportService>;
5822 interface ChildNode {
5823 after(...nodes: (Node | string)[]): void;
5824 before(...nodes: (Node | string)[]): void;
5826 replaceWith(...nodes: (Node | string)[]): void;
5829 interface ChildProcessMessageManager extends SyncMessageSender {
5832 declare var ChildProcessMessageManager: {
5833 prototype: ChildProcessMessageManager;
5834 new(): ChildProcessMessageManager;
5835 isInstance: IsInstance<ChildProcessMessageManager>;
5838 interface ChildSHistory {
5839 readonly count: number;
5840 readonly index: number;
5841 readonly legacySHistory: nsISHistory;
5842 canGo(aOffset: number): boolean;
5843 go(aOffset: number, aRequireUserInteraction?: boolean, aUserActivation?: boolean): void;
5844 reload(aReloadFlags: number): void;
5847 declare var ChildSHistory: {
5848 prototype: ChildSHistory;
5849 new(): ChildSHistory;
5850 isInstance: IsInstance<ChildSHistory>;
5853 interface ChromeMessageBroadcaster extends MessageBroadcaster, FrameScriptLoader {
5856 declare var ChromeMessageBroadcaster: {
5857 prototype: ChromeMessageBroadcaster;
5858 new(): ChromeMessageBroadcaster;
5859 isInstance: IsInstance<ChromeMessageBroadcaster>;
5862 interface ChromeMessageSender extends MessageSender, FrameScriptLoader {
5865 declare var ChromeMessageSender: {
5866 prototype: ChromeMessageSender;
5867 new(): ChromeMessageSender;
5868 isInstance: IsInstance<ChromeMessageSender>;
5871 interface ChromeNodeList extends NodeList {
5872 append(aNode: Node): void;
5873 remove(aNode: Node): void;
5876 declare var ChromeNodeList: {
5877 prototype: ChromeNodeList;
5878 new(): ChromeNodeList;
5879 isInstance: IsInstance<ChromeNodeList>;
5882 interface ChromeWorker extends Worker {
5883 addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: ChromeWorker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
5884 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
5885 removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: ChromeWorker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
5886 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
5889 declare var ChromeWorker: {
5890 prototype: ChromeWorker;
5891 new(scriptURL: string | URL, options?: WorkerOptions): ChromeWorker;
5892 isInstance: IsInstance<ChromeWorker>;
5895 /** Available only in secure contexts. */
5896 interface Clipboard extends EventTarget {
5897 read(): Promise<ClipboardItems>;
5898 readText(): Promise<string>;
5899 write(data: ClipboardItems): Promise<void>;
5900 writeText(data: string): Promise<void>;
5903 declare var Clipboard: {
5904 prototype: Clipboard;
5906 isInstance: IsInstance<Clipboard>;
5909 interface ClipboardEvent extends Event {
5910 readonly clipboardData: DataTransfer | null;
5913 declare var ClipboardEvent: {
5914 prototype: ClipboardEvent;
5915 new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
5916 isInstance: IsInstance<ClipboardEvent>;
5919 /** Available only in secure contexts. */
5920 interface ClipboardItem {
5921 readonly presentationStyle: PresentationStyle;
5922 readonly types: string[];
5923 getType(type: string): Promise<Blob>;
5926 declare var ClipboardItem: {
5927 prototype: ClipboardItem;
5928 new(items: Record<string, ClipboardItemDataType | PromiseLike<ClipboardItemDataType>>, options?: ClipboardItemOptions): ClipboardItem;
5929 isInstance: IsInstance<ClipboardItem>;
5930 supports(type: string): boolean;
5933 interface ClonedErrorHolder {
5936 declare var ClonedErrorHolder: {
5937 prototype: ClonedErrorHolder;
5938 new(aError: any): ClonedErrorHolder;
5939 isInstance: IsInstance<ClonedErrorHolder>;
5942 interface CloseEvent extends Event {
5943 readonly code: number;
5944 readonly reason: string;
5945 readonly wasClean: boolean;
5948 declare var CloseEvent: {
5949 prototype: CloseEvent;
5950 new(type: string, eventInitDict?: CloseEventInit): CloseEvent;
5951 isInstance: IsInstance<CloseEvent>;
5954 interface CommandEvent extends Event {
5955 readonly command: string | null;
5958 declare var CommandEvent: {
5959 prototype: CommandEvent;
5960 new(): CommandEvent;
5961 isInstance: IsInstance<CommandEvent>;
5964 interface Comment extends CharacterData {
5967 declare var Comment: {
5969 new(data?: string): Comment;
5970 isInstance: IsInstance<Comment>;
5973 interface CompositionEvent extends UIEvent {
5974 readonly data: string | null;
5975 readonly locale: string;
5976 readonly ranges: TextClause[];
5977 initCompositionEvent(typeArg: string, canBubbleArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, dataArg?: string | null, localeArg?: string): void;
5980 declare var CompositionEvent: {
5981 prototype: CompositionEvent;
5982 new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent;
5983 isInstance: IsInstance<CompositionEvent>;
5986 interface CompressionStream extends GenericTransformStream {
5989 declare var CompressionStream: {
5990 prototype: CompressionStream;
5991 new(format: CompressionFormat): CompressionStream;
5992 isInstance: IsInstance<CompressionStream>;
5995 interface ConsoleInstance {
5996 assert(condition?: boolean, ...data: any[]): void;
5998 count(label?: string): void;
5999 countReset(label?: string): void;
6000 debug(...data: any[]): void;
6001 dir(...data: any[]): void;
6002 dirxml(...data: any[]): void;
6003 error(...data: any[]): void;
6004 exception(...data: any[]): void;
6005 group(...data: any[]): void;
6006 groupCollapsed(...data: any[]): void;
6008 info(...data: any[]): void;
6009 log(...data: any[]): void;
6010 profile(...data: any[]): void;
6011 profileEnd(...data: any[]): void;
6012 reportForServiceWorkerScope(scope: string, message: string, filename: string, lineNumber: number, columnNumber: number, level: ConsoleLevel): void;
6013 shouldLog(level: ConsoleLogLevel): boolean;
6014 table(...data: any[]): void;
6015 time(label?: string): void;
6016 timeEnd(label?: string): void;
6017 timeLog(label?: string, ...data: any[]): void;
6018 timeStamp(data?: any): void;
6019 trace(...data: any[]): void;
6020 warn(...data: any[]): void;
6023 declare var ConsoleInstance: {
6024 prototype: ConsoleInstance;
6025 new(): ConsoleInstance;
6026 isInstance: IsInstance<ConsoleInstance>;
6029 interface ConstantSourceNode extends AudioScheduledSourceNode {
6030 readonly offset: AudioParam;
6031 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
6032 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
6033 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: ConstantSourceNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
6034 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
6037 declare var ConstantSourceNode: {
6038 prototype: ConstantSourceNode;
6039 new(context: BaseAudioContext, options?: ConstantSourceOptions): ConstantSourceNode;
6040 isInstance: IsInstance<ConstantSourceNode>;
6043 interface ContentFrameMessageManager extends EventTarget, MessageListenerManagerMixin, MessageManagerGlobal, MessageSenderMixin, SyncMessageSenderMixin {
6044 readonly content: WindowProxy | null;
6045 readonly docShell: nsIDocShell | null;
6046 readonly tabEventTarget: nsIEventTarget | null;
6049 declare var ContentFrameMessageManager: {
6050 prototype: ContentFrameMessageManager;
6051 new(): ContentFrameMessageManager;
6052 isInstance: IsInstance<ContentFrameMessageManager>;
6055 interface ContentProcessMessageManager extends MessageListenerManagerMixin, MessageManagerGlobal, MessageSenderMixin, SyncMessageSenderMixin {
6056 readonly initialProcessData: any;
6057 readonly sharedData: MozSharedMap | null;
6060 declare var ContentProcessMessageManager: {
6061 prototype: ContentProcessMessageManager;
6062 new(): ContentProcessMessageManager;
6063 isInstance: IsInstance<ContentProcessMessageManager>;
6066 interface ContentSecurityPolicy {
6069 interface ContentVisibilityAutoStateChangeEvent extends Event {
6070 readonly skipped: boolean;
6073 declare var ContentVisibilityAutoStateChangeEvent: {
6074 prototype: ContentVisibilityAutoStateChangeEvent;
6075 new(type: string, eventInitDict?: ContentVisibilityAutoStateChangeEventInit): ContentVisibilityAutoStateChangeEvent;
6076 isInstance: IsInstance<ContentVisibilityAutoStateChangeEvent>;
6079 interface ConvolverNode extends AudioNode, AudioNodePassThrough {
6080 buffer: AudioBuffer | null;
6084 declare var ConvolverNode: {
6085 prototype: ConvolverNode;
6086 new(context: BaseAudioContext, options?: ConvolverOptions): ConvolverNode;
6087 isInstance: IsInstance<ConvolverNode>;
6093 interface CountQueuingStrategy {
6094 readonly highWaterMark: number;
6095 readonly size: Function;
6098 declare var CountQueuingStrategy: {
6099 prototype: CountQueuingStrategy;
6100 new(init: QueuingStrategyInit): CountQueuingStrategy;
6101 isInstance: IsInstance<CountQueuingStrategy>;
6104 interface CreateOfferRequest {
6105 readonly callID: string;
6106 readonly innerWindowID: number;
6107 readonly isSecure: boolean;
6108 readonly windowID: number;
6111 declare var CreateOfferRequest: {
6112 prototype: CreateOfferRequest;
6113 new(): CreateOfferRequest;
6114 isInstance: IsInstance<CreateOfferRequest>;
6117 /** Available only in secure contexts. */
6118 interface Credential {
6119 readonly id: string;
6120 readonly type: string;
6123 declare var Credential: {
6124 prototype: Credential;
6126 isInstance: IsInstance<Credential>;
6129 /** Available only in secure contexts. */
6130 interface CredentialsContainer {
6131 create(options?: CredentialCreationOptions): Promise<Credential | null>;
6132 get(options?: CredentialRequestOptions): Promise<Credential | null>;
6133 preventSilentAccess(): Promise<void>;
6134 store(credential: Credential): Promise<Credential>;
6137 declare var CredentialsContainer: {
6138 prototype: CredentialsContainer;
6139 new(): CredentialsContainer;
6140 isInstance: IsInstance<CredentialsContainer>;
6144 /** Available only in secure contexts. */
6145 readonly subtle: SubtleCrypto;
6146 getRandomValues(array: ArrayBufferView): ArrayBufferView;
6147 /** Available only in secure contexts. */
6148 randomUUID(): string;
6151 declare var Crypto: {
6154 isInstance: IsInstance<Crypto>;
6157 /** Available only in secure contexts. */
6158 interface CryptoKey {
6159 readonly algorithm: any;
6160 readonly extractable: boolean;
6161 readonly type: KeyType;
6162 readonly usages: KeyUsage[];
6165 declare var CryptoKey: {
6166 prototype: CryptoKey;
6168 isInstance: IsInstance<CryptoKey>;
6171 interface CustomElementRegistry {
6172 define(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
6173 get(name: string): CustomElementConstructor | undefined;
6174 getName(constructor: CustomElementConstructor): string | null;
6175 setElementCreationCallback(name: string, callback: CustomElementCreationCallback): void;
6176 upgrade(root: Node): void;
6177 whenDefined(name: string): Promise<CustomElementConstructor>;
6180 declare var CustomElementRegistry: {
6181 prototype: CustomElementRegistry;
6182 new(): CustomElementRegistry;
6183 isInstance: IsInstance<CustomElementRegistry>;
6186 interface CustomEvent extends Event {
6187 readonly detail: any;
6188 initCustomEvent(type: string, canBubble?: boolean, cancelable?: boolean, detail?: any): void;
6191 declare var CustomEvent: {
6192 prototype: CustomEvent;
6193 new(type: string, eventInitDict?: CustomEventInit): CustomEvent;
6194 isInstance: IsInstance<CustomEvent>;
6197 interface CustomStateSet {
6198 forEach(callbackfn: (value: string, key: string, parent: CustomStateSet) => void, thisArg?: any): void;
6201 declare var CustomStateSet: {
6202 prototype: CustomStateSet;
6203 new(): CustomStateSet;
6204 isInstance: IsInstance<CustomStateSet>;
6207 interface DOMApplication {
6210 interface DOMException extends ExceptionMembers {
6211 readonly code: number;
6212 readonly message: string;
6213 readonly name: string;
6214 readonly INDEX_SIZE_ERR: 1;
6215 readonly DOMSTRING_SIZE_ERR: 2;
6216 readonly HIERARCHY_REQUEST_ERR: 3;
6217 readonly WRONG_DOCUMENT_ERR: 4;
6218 readonly INVALID_CHARACTER_ERR: 5;
6219 readonly NO_DATA_ALLOWED_ERR: 6;
6220 readonly NO_MODIFICATION_ALLOWED_ERR: 7;
6221 readonly NOT_FOUND_ERR: 8;
6222 readonly NOT_SUPPORTED_ERR: 9;
6223 readonly INUSE_ATTRIBUTE_ERR: 10;
6224 readonly INVALID_STATE_ERR: 11;
6225 readonly SYNTAX_ERR: 12;
6226 readonly INVALID_MODIFICATION_ERR: 13;
6227 readonly NAMESPACE_ERR: 14;
6228 readonly INVALID_ACCESS_ERR: 15;
6229 readonly VALIDATION_ERR: 16;
6230 readonly TYPE_MISMATCH_ERR: 17;
6231 readonly SECURITY_ERR: 18;
6232 readonly NETWORK_ERR: 19;
6233 readonly ABORT_ERR: 20;
6234 readonly URL_MISMATCH_ERR: 21;
6235 readonly QUOTA_EXCEEDED_ERR: 22;
6236 readonly TIMEOUT_ERR: 23;
6237 readonly INVALID_NODE_TYPE_ERR: 24;
6238 readonly DATA_CLONE_ERR: 25;
6241 declare var DOMException: {
6242 prototype: DOMException;
6243 new(message?: string, name?: string): DOMException;
6244 readonly INDEX_SIZE_ERR: 1;
6245 readonly DOMSTRING_SIZE_ERR: 2;
6246 readonly HIERARCHY_REQUEST_ERR: 3;
6247 readonly WRONG_DOCUMENT_ERR: 4;
6248 readonly INVALID_CHARACTER_ERR: 5;
6249 readonly NO_DATA_ALLOWED_ERR: 6;
6250 readonly NO_MODIFICATION_ALLOWED_ERR: 7;
6251 readonly NOT_FOUND_ERR: 8;
6252 readonly NOT_SUPPORTED_ERR: 9;
6253 readonly INUSE_ATTRIBUTE_ERR: 10;
6254 readonly INVALID_STATE_ERR: 11;
6255 readonly SYNTAX_ERR: 12;
6256 readonly INVALID_MODIFICATION_ERR: 13;
6257 readonly NAMESPACE_ERR: 14;
6258 readonly INVALID_ACCESS_ERR: 15;
6259 readonly VALIDATION_ERR: 16;
6260 readonly TYPE_MISMATCH_ERR: 17;
6261 readonly SECURITY_ERR: 18;
6262 readonly NETWORK_ERR: 19;
6263 readonly ABORT_ERR: 20;
6264 readonly URL_MISMATCH_ERR: 21;
6265 readonly QUOTA_EXCEEDED_ERR: 22;
6266 readonly TIMEOUT_ERR: 23;
6267 readonly INVALID_NODE_TYPE_ERR: 24;
6268 readonly DATA_CLONE_ERR: 25;
6269 isInstance: IsInstance<DOMException>;
6272 interface DOMImplementation {
6273 createDocument(namespace: string | null, qualifiedName: string | null, doctype?: DocumentType | null): Document;
6274 createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
6275 createHTMLDocument(title?: string): Document;
6276 hasFeature(): boolean;
6279 declare var DOMImplementation: {
6280 prototype: DOMImplementation;
6281 new(): DOMImplementation;
6282 isInstance: IsInstance<DOMImplementation>;
6285 interface DOMLocalization extends Localization {
6286 connectRoot(aElement: Node): void;
6287 disconnectRoot(aElement: Node): void;
6288 getAttributes(aElement: Element): L10nIdArgs;
6289 pauseObserving(): void;
6290 resumeObserving(): void;
6291 setArgs(aElement: Element, aArgs?: any): void;
6292 setAttributes(aElement: Element, aId: string, aArgs?: any): void;
6293 translateElements(aElements: Element[]): Promise<void>;
6294 translateFragment(aNode: Node): Promise<any>;
6295 translateRoots(): Promise<void>;
6298 declare var DOMLocalization: {
6299 prototype: DOMLocalization;
6300 new(aResourceIds: L10nResourceId[], aSync?: boolean, aRegistry?: L10nRegistry, aLocales?: string[]): DOMLocalization;
6301 isInstance: IsInstance<DOMLocalization>;
6304 interface DOMMatrix extends DOMMatrixReadOnly {
6327 invertSelf(): DOMMatrix;
6328 multiplySelf(other?: DOMMatrixInit): DOMMatrix;
6329 preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
6330 rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
6331 rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
6332 rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
6333 scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
6334 scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
6335 setMatrixValue(transformList: string): DOMMatrix;
6336 skewXSelf(sx?: number): DOMMatrix;
6337 skewYSelf(sy?: number): DOMMatrix;
6338 translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
6341 declare var DOMMatrix: {
6342 prototype: DOMMatrix;
6343 new(init?: string | number[] | DOMMatrixReadOnly): DOMMatrix;
6344 isInstance: IsInstance<DOMMatrix>;
6345 fromFloat32Array(array32: Float32Array): DOMMatrix;
6346 fromFloat64Array(array64: Float64Array): DOMMatrix;
6347 fromMatrix(other?: DOMMatrixInit): DOMMatrix;
6350 type WebKitCSSMatrix = DOMMatrix;
6351 declare var WebKitCSSMatrix: typeof DOMMatrix;
6353 interface DOMMatrixReadOnly {
6360 readonly is2D: boolean;
6361 readonly isIdentity: boolean;
6362 readonly m11: number;
6363 readonly m12: number;
6364 readonly m13: number;
6365 readonly m14: number;
6366 readonly m21: number;
6367 readonly m22: number;
6368 readonly m23: number;
6369 readonly m24: number;
6370 readonly m31: number;
6371 readonly m32: number;
6372 readonly m33: number;
6373 readonly m34: number;
6374 readonly m41: number;
6375 readonly m42: number;
6376 readonly m43: number;
6377 readonly m44: number;
6380 inverse(): DOMMatrix;
6381 multiply(other?: DOMMatrixInit): DOMMatrix;
6382 rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
6383 rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;
6384 rotateFromVector(x?: number, y?: number): DOMMatrix;
6385 scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
6386 scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;
6387 scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
6388 skewX(sx?: number): DOMMatrix;
6389 skewY(sy?: number): DOMMatrix;
6390 toFloat32Array(): Float32Array;
6391 toFloat64Array(): Float64Array;
6393 transformPoint(point?: DOMPointInit): DOMPoint;
6394 translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
6398 declare var DOMMatrixReadOnly: {
6399 prototype: DOMMatrixReadOnly;
6400 new(init?: string | number[] | DOMMatrixReadOnly): DOMMatrixReadOnly;
6401 isInstance: IsInstance<DOMMatrixReadOnly>;
6402 fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
6403 fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
6404 fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
6407 interface DOMParser {
6408 forceEnableDTD(): void;
6409 forceEnableXULXBL(): void;
6410 parseFromBuffer(buf: number[], type: SupportedType): Document;
6411 parseFromBuffer(buf: Uint8Array, type: SupportedType): Document;
6412 parseFromSafeString(str: string, type: SupportedType): Document;
6413 parseFromStream(stream: InputStream, charset: string | null, contentLength: number, type: SupportedType): Document;
6414 parseFromString(str: string, type: SupportedType): Document;
6417 declare var DOMParser: {
6418 prototype: DOMParser;
6420 isInstance: IsInstance<DOMParser>;
6423 interface DOMPoint extends DOMPointReadOnly {
6430 declare var DOMPoint: {
6431 prototype: DOMPoint;
6432 new(x?: number, y?: number, z?: number, w?: number): DOMPoint;
6433 isInstance: IsInstance<DOMPoint>;
6434 fromPoint(other?: DOMPointInit): DOMPoint;
6437 interface DOMPointReadOnly {
6442 matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
6446 declare var DOMPointReadOnly: {
6447 prototype: DOMPointReadOnly;
6448 new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
6449 isInstance: IsInstance<DOMPointReadOnly>;
6450 fromPoint(other?: DOMPointInit): DOMPointReadOnly;
6454 readonly p1: DOMPoint;
6455 readonly p2: DOMPoint;
6456 readonly p3: DOMPoint;
6457 readonly p4: DOMPoint;
6458 getBounds(): DOMRectReadOnly;
6462 declare var DOMQuad: {
6464 new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
6465 new(rect: DOMRectReadOnly): DOMQuad;
6466 isInstance: IsInstance<DOMQuad>;
6467 fromQuad(other?: DOMQuadInit): DOMQuad;
6468 fromRect(other?: DOMRectInit): DOMQuad;
6471 interface DOMRect extends DOMRectReadOnly {
6478 declare var DOMRect: {
6480 new(x?: number, y?: number, width?: number, height?: number): DOMRect;
6481 isInstance: IsInstance<DOMRect>;
6482 fromRect(other?: DOMRectInit): DOMRect;
6485 interface DOMRectList {
6486 readonly length: number;
6487 item(index: number): DOMRect | null;
6488 [index: number]: DOMRect;
6491 declare var DOMRectList: {
6492 prototype: DOMRectList;
6494 isInstance: IsInstance<DOMRectList>;
6497 interface DOMRectReadOnly {
6498 readonly bottom: number;
6499 readonly height: number;
6500 readonly left: number;
6501 readonly right: number;
6502 readonly top: number;
6503 readonly width: number;
6509 declare var DOMRectReadOnly: {
6510 prototype: DOMRectReadOnly;
6511 new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
6512 isInstance: IsInstance<DOMRectReadOnly>;
6513 fromRect(other?: DOMRectInit): DOMRectReadOnly;
6516 interface DOMStringList {
6517 readonly length: number;
6518 contains(string: string): boolean;
6519 item(index: number): string | null;
6520 [index: number]: string;
6523 declare var DOMStringList: {
6524 prototype: DOMStringList;
6525 new(): DOMStringList;
6526 isInstance: IsInstance<DOMStringList>;
6529 interface DOMStringMap {
6532 declare var DOMStringMap: {
6533 prototype: DOMStringMap;
6534 new(): DOMStringMap;
6535 isInstance: IsInstance<DOMStringMap>;
6538 interface DOMTokenList {
6539 readonly length: number;
6542 add(...tokens: string[]): void;
6543 contains(token: string): boolean;
6544 item(index: number): string | null;
6545 remove(...tokens: string[]): void;
6546 replace(token: string, newToken: string): boolean;
6547 supports(token: string): boolean;
6548 toggle(token: string, force?: boolean): boolean;
6549 forEach(callbackfn: (value: string | null, key: number, parent: DOMTokenList) => void, thisArg?: any): void;
6550 [index: number]: string;
6553 declare var DOMTokenList: {
6554 prototype: DOMTokenList;
6555 new(): DOMTokenList;
6556 isInstance: IsInstance<DOMTokenList>;
6559 interface DataTransfer {
6561 effectAllowed: string;
6562 readonly files: FileList | null;
6563 readonly items: DataTransferItemList;
6564 readonly mozCSP: ContentSecurityPolicy | null;
6566 readonly mozItemCount: number;
6567 mozShowFailAnimation: boolean;
6568 readonly mozSourceNode: Node | null;
6569 readonly mozTriggeringPrincipalURISpec: string;
6570 readonly mozUserCancelled: boolean;
6571 readonly sourceTopWindowContext: WindowContext | null;
6572 readonly types: string[];
6573 addElement(element: Element): void;
6574 clearData(format?: string): void;
6575 getData(format: string): string;
6576 mozClearDataAt(format: string, index: number): void;
6577 mozCloneForEvent(event: string): DataTransfer;
6578 mozGetDataAt(format: string, index: number): any;
6579 mozSetDataAt(format: string, data: any, index: number): void;
6580 mozTypesAt(index: number): DOMStringList;
6581 setData(format: string, data: string): void;
6582 setDragImage(image: Element, x: number, y: number): void;
6583 updateDragImage(image: Element, x: number, y: number): void;
6586 declare var DataTransfer: {
6587 prototype: DataTransfer;
6588 new(): DataTransfer;
6589 isInstance: IsInstance<DataTransfer>;
6592 interface DataTransferItem {
6593 readonly kind: string;
6594 readonly type: string;
6595 getAsFile(): File | null;
6596 getAsString(callback: FunctionStringCallback | null): void;
6597 webkitGetAsEntry(): FileSystemEntry | null;
6600 declare var DataTransferItem: {
6601 prototype: DataTransferItem;
6602 new(): DataTransferItem;
6603 isInstance: IsInstance<DataTransferItem>;
6606 interface DataTransferItemList {
6607 readonly length: number;
6608 add(data: string, type: string): DataTransferItem | null;
6609 add(data: File): DataTransferItem | null;
6611 remove(index: number): void;
6612 [index: number]: DataTransferItem;
6615 declare var DataTransferItemList: {
6616 prototype: DataTransferItemList;
6617 new(): DataTransferItemList;
6618 isInstance: IsInstance<DataTransferItemList>;
6621 interface DebuggerNotification {
6622 readonly global: any;
6623 readonly type: DebuggerNotificationType;
6626 declare var DebuggerNotification: {
6627 prototype: DebuggerNotification;
6628 new(): DebuggerNotification;
6629 isInstance: IsInstance<DebuggerNotification>;
6632 interface DebuggerNotificationObserver {
6633 addListener(handler: DebuggerNotificationCallback): boolean;
6634 connect(global: any): boolean;
6635 disconnect(global: any): boolean;
6636 removeListener(handler: DebuggerNotificationCallback): boolean;
6639 declare var DebuggerNotificationObserver: {
6640 prototype: DebuggerNotificationObserver;
6641 new(): DebuggerNotificationObserver;
6642 isInstance: IsInstance<DebuggerNotificationObserver>;
6645 interface DecompressionStream extends GenericTransformStream {
6648 declare var DecompressionStream: {
6649 prototype: DecompressionStream;
6650 new(format: CompressionFormat): DecompressionStream;
6651 isInstance: IsInstance<DecompressionStream>;
6654 interface DelayNode extends AudioNode, AudioNodePassThrough {
6655 readonly delayTime: AudioParam;
6658 declare var DelayNode: {
6659 prototype: DelayNode;
6660 new(context: BaseAudioContext, options?: DelayOptions): DelayNode;
6661 isInstance: IsInstance<DelayNode>;
6664 interface DeprecationReportBody extends ReportBody {
6665 readonly anticipatedRemoval: DOMTimeStamp | null;
6666 readonly columnNumber: number | null;
6667 readonly id: string;
6668 readonly lineNumber: number | null;
6669 readonly message: string;
6670 readonly sourceFile: string | null;
6673 declare var DeprecationReportBody: {
6674 prototype: DeprecationReportBody;
6675 new(): DeprecationReportBody;
6676 isInstance: IsInstance<DeprecationReportBody>;
6679 interface DeviceAcceleration {
6680 readonly x: number | null;
6681 readonly y: number | null;
6682 readonly z: number | null;
6685 interface DeviceLightEvent extends Event {
6686 readonly value: number;
6689 declare var DeviceLightEvent: {
6690 prototype: DeviceLightEvent;
6691 new(type: string, eventInitDict?: DeviceLightEventInit): DeviceLightEvent;
6692 isInstance: IsInstance<DeviceLightEvent>;
6695 interface DeviceMotionEvent extends Event {
6696 readonly acceleration: DeviceAcceleration | null;
6697 readonly accelerationIncludingGravity: DeviceAcceleration | null;
6698 readonly interval: number | null;
6699 readonly rotationRate: DeviceRotationRate | null;
6700 initDeviceMotionEvent(type: string, canBubble?: boolean, cancelable?: boolean, acceleration?: DeviceAccelerationInit, accelerationIncludingGravity?: DeviceAccelerationInit, rotationRate?: DeviceRotationRateInit, interval?: number | null): void;
6703 declare var DeviceMotionEvent: {
6704 prototype: DeviceMotionEvent;
6705 new(type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent;
6706 isInstance: IsInstance<DeviceMotionEvent>;
6709 interface DeviceOrientationEvent extends Event {
6710 readonly absolute: boolean;
6711 readonly alpha: number | null;
6712 readonly beta: number | null;
6713 readonly gamma: number | null;
6714 initDeviceOrientationEvent(type: string, canBubble?: boolean, cancelable?: boolean, alpha?: number | null, beta?: number | null, gamma?: number | null, absolute?: boolean): void;
6717 declare var DeviceOrientationEvent: {
6718 prototype: DeviceOrientationEvent;
6719 new(type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent;
6720 isInstance: IsInstance<DeviceOrientationEvent>;
6723 interface DeviceRotationRate {
6724 readonly alpha: number | null;
6725 readonly beta: number | null;
6726 readonly gamma: number | null;
6729 interface Directory {
6730 readonly name: string;
6731 readonly path: string;
6732 getFiles(recursiveFlag?: boolean): Promise<File[]>;
6733 getFilesAndDirectories(): Promise<(File | Directory)[]>;
6736 declare var Directory: {
6737 prototype: Directory;
6738 new(path: string): Directory;
6739 isInstance: IsInstance<Directory>;
6742 interface DocumentEventMap extends GlobalEventHandlersEventMap, OnErrorEventHandlerForNodesEventMap, TouchEventHandlersEventMap {
6743 "afterscriptexecute": Event;
6744 "beforescriptexecute": Event;
6745 "fullscreenchange": Event;
6746 "fullscreenerror": Event;
6747 "pointerlockchange": Event;
6748 "pointerlockerror": Event;
6749 "readystatechange": Event;
6750 "visibilitychange": Event;
6753 interface Document extends Node, DocumentOrShadowRoot, FontFaceSource, GeometryUtils, GlobalEventHandlers, NonElementParentNode, OnErrorEventHandlerForNodes, ParentNode, TouchEventHandlers, XPathEvaluatorMixin {
6754 readonly URL: string;
6756 readonly all: HTMLAllCollection;
6757 readonly anchors: HTMLCollection;
6758 readonly applets: HTMLCollection;
6760 readonly blockedNodeByClassifierCount: number;
6761 readonly blockedNodesByClassifier: NodeList;
6762 body: HTMLElement | null;
6763 readonly characterSet: string;
6764 readonly charset: string;
6765 readonly commandDispatcher: XULCommandDispatcher | null;
6766 readonly compatMode: string;
6767 readonly contentLanguage: string;
6768 readonly contentType: string;
6770 readonly cookieJarSettings: nsICookieJarSettings;
6771 readonly csp: ContentSecurityPolicy | null;
6772 readonly cspJSON: string;
6773 readonly currentScript: Element | null;
6774 readonly defaultView: WindowProxy | null;
6776 devToolsAnonymousAndShadowEventsEnabled: boolean;
6777 devToolsWatchingDOMMutations: boolean;
6779 readonly doctype: DocumentType | null;
6780 readonly documentElement: Element | null;
6781 readonly documentLoadGroup: nsILoadGroup | null;
6782 readonly documentReadyForIdle: Promise<undefined>;
6783 readonly documentURI: string;
6784 readonly documentURIObject: URI | null;
6786 readonly effectiveStoragePrincipal: Principal;
6787 readonly embeds: HTMLCollection;
6788 readonly featurePolicy: FeaturePolicy;
6790 readonly forms: HTMLCollection;
6791 readonly fragmentDirective: FragmentDirective;
6792 readonly fullscreen: boolean;
6793 readonly fullscreenEnabled: boolean;
6794 readonly hasBeenUserGestureActivated: boolean;
6795 readonly hasPendingL10nMutations: boolean;
6796 readonly hasValidTransientUserGestureActivation: boolean;
6797 readonly head: HTMLHeadElement | null;
6798 readonly hidden: boolean;
6799 readonly images: HTMLCollection;
6800 readonly implementation: DOMImplementation;
6801 readonly inputEncoding: string;
6802 readonly isInitialDocument: boolean;
6803 readonly isSrcdocDocument: boolean;
6804 readonly l10n: DocumentL10n | null;
6805 readonly lastModified: string;
6806 readonly lastStyleSheetSet: string | null;
6807 readonly lastUserGestureTimeStamp: DOMHighResTimeStamp;
6809 readonly links: HTMLCollection;
6810 readonly loadedFromPrototype: boolean;
6811 readonly location: Location | null;
6812 readonly mozDocumentURIIfNotForErrorPages: URI | null;
6813 readonly mozFullScreen: boolean;
6814 readonly mozFullScreenEnabled: boolean;
6815 readonly mozSyntheticDocument: boolean;
6816 onafterscriptexecute: ((this: Document, ev: Event) => any) | null;
6817 onbeforescriptexecute: ((this: Document, ev: Event) => any) | null;
6818 onfullscreenchange: ((this: Document, ev: Event) => any) | null;
6819 onfullscreenerror: ((this: Document, ev: Event) => any) | null;
6820 onpointerlockchange: ((this: Document, ev: Event) => any) | null;
6821 onpointerlockerror: ((this: Document, ev: Event) => any) | null;
6822 onreadystatechange: ((this: Document, ev: Event) => any) | null;
6823 onvisibilitychange: ((this: Document, ev: Event) => any) | null;
6824 readonly partitionedPrincipal: Principal;
6825 readonly permDelegateHandler: nsIPermissionDelegateHandler;
6826 readonly plugins: HTMLCollection;
6827 readonly preferredStyleSheetSet: string | null;
6828 readonly readyState: string;
6829 readonly referrer: string;
6830 readonly referrerInfo: nsIReferrerInfo;
6831 readonly referrerPolicy: ReferrerPolicy;
6832 readonly rootElement: SVGSVGElement | null;
6833 readonly sandboxFlagsAsString: string | null;
6834 readonly scripts: HTMLCollection;
6835 readonly scrollingElement: Element | null;
6836 selectedStyleSheetSet: string | null;
6837 styleSheetChangeEventsEnabled: boolean;
6838 readonly styleSheetSets: DOMStringList;
6839 readonly timeline: DocumentTimeline;
6841 readonly userHasInteracted: boolean;
6842 readonly visibilityState: VisibilityState;
6844 addCertException(isTemporary: boolean): Promise<any>;
6845 adoptNode(node: Node): Node;
6846 blockParsing(promise: any, options?: BlockParsingOptions): Promise<any>;
6847 blockUnblockOnload(block: boolean): void;
6848 captureEvents(): void;
6849 caretPositionFromPoint(x: number, y: number): CaretPosition | null;
6851 clearUserGestureActivation(): void;
6853 completeStorageAccessRequestFromSite(serializedSite: string): Promise<void>;
6854 consumeTransientUserGestureActivation(): boolean;
6855 createAttribute(name: string): Attr;
6856 createAttributeNS(namespace: string | null, name: string): Attr;
6857 createCDATASection(data: string): CDATASection;
6858 createComment(data: string): Comment;
6859 createDocumentFragment(): DocumentFragment;
6860 createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
6862 createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
6863 createElement(tagName: string, options?: ElementCreationOptions): HTMLElement;
6864 createElementNS(namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
6865 createEvent(eventInterface: "AddonEvent"): AddonEvent;
6866 createEvent(eventInterface: "AnimationEvent"): AnimationEvent;
6867 createEvent(eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
6868 createEvent(eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
6869 createEvent(eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
6870 createEvent(eventInterface: "BlobEvent"): BlobEvent;
6871 createEvent(eventInterface: "CSSCustomPropertyRegisteredEvent"): CSSCustomPropertyRegisteredEvent;
6872 createEvent(eventInterface: "CaretStateChangedEvent"): CaretStateChangedEvent;
6873 createEvent(eventInterface: "ClipboardEvent"): ClipboardEvent;
6874 createEvent(eventInterface: "CloseEvent"): CloseEvent;
6875 createEvent(eventInterface: "CommandEvent"): CommandEvent;
6876 createEvent(eventInterface: "CompositionEvent"): CompositionEvent;
6877 createEvent(eventInterface: "ContentVisibilityAutoStateChangeEvent"): ContentVisibilityAutoStateChangeEvent;
6878 createEvent(eventInterface: "CustomEvent"): CustomEvent;
6879 createEvent(eventInterface: "DeviceLightEvent"): DeviceLightEvent;
6880 createEvent(eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
6881 createEvent(eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
6882 createEvent(eventInterface: "DragEvent"): DragEvent;
6883 createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
6884 createEvent(eventInterface: "FocusEvent"): FocusEvent;
6885 createEvent(eventInterface: "FontFaceSetLoadEvent"): FontFaceSetLoadEvent;
6886 createEvent(eventInterface: "FormDataEvent"): FormDataEvent;
6887 createEvent(eventInterface: "FrameCrashedEvent"): FrameCrashedEvent;
6888 createEvent(eventInterface: "GPUUncapturedErrorEvent"): GPUUncapturedErrorEvent;
6889 createEvent(eventInterface: "GamepadAxisMoveEvent"): GamepadAxisMoveEvent;
6890 createEvent(eventInterface: "GamepadButtonEvent"): GamepadButtonEvent;
6891 createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
6892 createEvent(eventInterface: "HashChangeEvent"): HashChangeEvent;
6893 createEvent(eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
6894 createEvent(eventInterface: "ImageCaptureErrorEvent"): ImageCaptureErrorEvent;
6895 createEvent(eventInterface: "InputEvent"): InputEvent;
6896 createEvent(eventInterface: "InvokeEvent"): InvokeEvent;
6897 createEvent(eventInterface: "KeyboardEvent"): KeyboardEvent;
6898 createEvent(eventInterface: "MIDIConnectionEvent"): MIDIConnectionEvent;
6899 createEvent(eventInterface: "MIDIMessageEvent"): MIDIMessageEvent;
6900 createEvent(eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
6901 createEvent(eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
6902 createEvent(eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
6903 createEvent(eventInterface: "MediaRecorderErrorEvent"): MediaRecorderErrorEvent;
6904 createEvent(eventInterface: "MediaStreamEvent"): MediaStreamEvent;
6905 createEvent(eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
6906 createEvent(eventInterface: "MerchantValidationEvent"): MerchantValidationEvent;
6907 createEvent(eventInterface: "MessageEvent"): MessageEvent;
6908 createEvent(eventInterface: "MouseEvent"): MouseEvent;
6909 createEvent(eventInterface: "MouseEvents"): MouseEvent;
6910 createEvent(eventInterface: "MouseScrollEvent"): MouseScrollEvent;
6911 createEvent(eventInterface: "MozApplicationEvent"): MozApplicationEvent;
6912 createEvent(eventInterface: "MozSharedMapChangeEvent"): MozSharedMapChangeEvent;
6913 createEvent(eventInterface: "MutationEvent"): MutationEvent;
6914 createEvent(eventInterface: "MutationEvents"): MutationEvent;
6915 createEvent(eventInterface: "NotifyPaintEvent"): NotifyPaintEvent;
6916 createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
6917 createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent;
6918 createEvent(eventInterface: "PaymentMethodChangeEvent"): PaymentMethodChangeEvent;
6919 createEvent(eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
6920 createEvent(eventInterface: "PerformanceEntryEvent"): PerformanceEntryEvent;
6921 createEvent(eventInterface: "PluginCrashedEvent"): PluginCrashedEvent;
6922 createEvent(eventInterface: "PointerEvent"): PointerEvent;
6923 createEvent(eventInterface: "PopStateEvent"): PopStateEvent;
6924 createEvent(eventInterface: "PopupBlockedEvent"): PopupBlockedEvent;
6925 createEvent(eventInterface: "PopupPositionedEvent"): PopupPositionedEvent;
6926 createEvent(eventInterface: "PositionStateEvent"): PositionStateEvent;
6927 createEvent(eventInterface: "ProgressEvent"): ProgressEvent;
6928 createEvent(eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
6929 createEvent(eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
6930 createEvent(eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
6931 createEvent(eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
6932 createEvent(eventInterface: "RTCTrackEvent"): RTCTrackEvent;
6933 createEvent(eventInterface: "ScrollAreaEvent"): ScrollAreaEvent;
6934 createEvent(eventInterface: "ScrollViewChangeEvent"): ScrollViewChangeEvent;
6935 createEvent(eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
6936 createEvent(eventInterface: "SimpleGestureEvent"): SimpleGestureEvent;
6937 createEvent(eventInterface: "SpeechRecognitionEvent"): SpeechRecognitionEvent;
6938 createEvent(eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
6939 createEvent(eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
6940 createEvent(eventInterface: "StorageEvent"): StorageEvent;
6941 createEvent(eventInterface: "StreamFilterDataEvent"): StreamFilterDataEvent;
6942 createEvent(eventInterface: "StyleSheetApplicableStateChangeEvent"): StyleSheetApplicableStateChangeEvent;
6943 createEvent(eventInterface: "StyleSheetRemovedEvent"): StyleSheetRemovedEvent;
6944 createEvent(eventInterface: "SubmitEvent"): SubmitEvent;
6945 createEvent(eventInterface: "TCPServerSocketEvent"): TCPServerSocketEvent;
6946 createEvent(eventInterface: "TCPSocketErrorEvent"): TCPSocketErrorEvent;
6947 createEvent(eventInterface: "TCPSocketEvent"): TCPSocketEvent;
6948 createEvent(eventInterface: "TaskPriorityChangeEvent"): TaskPriorityChangeEvent;
6949 createEvent(eventInterface: "TextEvent"): TextEvent;
6950 createEvent(eventInterface: "TimeEvent"): TimeEvent;
6951 createEvent(eventInterface: "ToggleEvent"): ToggleEvent;
6952 createEvent(eventInterface: "TouchEvent"): TouchEvent;
6953 createEvent(eventInterface: "TrackEvent"): TrackEvent;
6954 createEvent(eventInterface: "TransitionEvent"): TransitionEvent;
6955 createEvent(eventInterface: "UDPMessageEvent"): UDPMessageEvent;
6956 createEvent(eventInterface: "UIEvent"): UIEvent;
6957 createEvent(eventInterface: "UIEvents"): UIEvent;
6958 createEvent(eventInterface: "UserProximityEvent"): UserProximityEvent;
6959 createEvent(eventInterface: "VRDisplayEvent"): VRDisplayEvent;
6960 createEvent(eventInterface: "WebGLContextEvent"): WebGLContextEvent;
6961 createEvent(eventInterface: "WheelEvent"): WheelEvent;
6962 createEvent(eventInterface: "XRInputSourceEvent"): XRInputSourceEvent;
6963 createEvent(eventInterface: "XRInputSourcesChangeEvent"): XRInputSourcesChangeEvent;
6964 createEvent(eventInterface: "XRReferenceSpaceEvent"): XRReferenceSpaceEvent;
6965 createEvent(eventInterface: "XRSessionEvent"): XRSessionEvent;
6966 createEvent(eventInterface: "XULCommandEvent"): XULCommandEvent;
6967 createEvent(eventInterface: string): Event;
6968 createNodeIterator(root: Node, whatToShow?: number, filter?: NodeFilter | null): NodeIterator;
6969 createProcessingInstruction(target: string, data: string): ProcessingInstruction;
6970 createRange(): Range;
6971 createTextNode(data: string): Text;
6972 createTouch(view?: Window | null, target?: EventTarget | null, identifier?: number, pageX?: number, pageY?: number, screenX?: number, screenY?: number, clientX?: number, clientY?: number, radiusX?: number, radiusY?: number, rotationAngle?: number, force?: number): Touch;
6973 createTouchList(touch: Touch, ...touches: Touch[]): TouchList;
6974 createTouchList(): TouchList;
6975 createTouchList(touches: Touch[]): TouchList;
6976 createTreeWalker(root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
6977 createXULElement(localName: string, options?: string | ElementCreationOptions): Element;
6978 enableStyleSheetsForSet(name: string | null): void;
6979 execCommand(commandId: string, showUI?: boolean, value?: string): boolean;
6980 exitFullscreen(): Promise<void>;
6981 exitPointerLock(): void;
6982 getConnectedShadowRoots(): ShadowRoot[];
6983 getElementsByClassName(classNames: string): HTMLCollection;
6984 getElementsByName(elementName: string): NodeList;
6985 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(localName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
6986 getElementsByTagName<K extends keyof SVGElementTagNameMap>(localName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
6987 getElementsByTagName<K extends keyof MathMLElementTagNameMap>(localName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
6989 getElementsByTagName<K extends keyof HTMLElementDeprecatedTagNameMap>(localName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
6990 getElementsByTagName(localName: string): HTMLCollectionOf<Element>;
6991 getElementsByTagNameNS(namespace: string | null, localName: string): HTMLCollection;
6992 getFailedCertSecurityInfo(): FailedCertSecurityInfo;
6993 getNetErrorInfo(): NetErrorInfo;
6994 getSelection(): Selection | null;
6995 getWireframe(aIncludeNodes?: boolean): Wireframe | null;
6996 hasFocus(): boolean;
6997 hasStorageAccess(): Promise<boolean>;
6998 importNode(node: Node, deep?: boolean): Node;
6999 insertAnonymousContent(aForce?: boolean): AnonymousContent;
7000 isActive(): boolean;
7001 mozCancelFullScreen(): Promise<void>;
7002 mozSetImageElement(aImageElementId: string, aImageElement: Element | null): void;
7003 notifyUserGestureActivation(): void;
7004 open(unused1?: string, unused2?: string): Document;
7005 open(url: string | URL, name: string, features: string): WindowProxy | null;
7006 queryCommandEnabled(commandId: string): boolean;
7007 queryCommandIndeterm(commandId: string): boolean;
7008 queryCommandState(commandId: string): boolean;
7009 queryCommandSupported(commandId: string): boolean;
7010 queryCommandValue(commandId: string): string;
7011 releaseCapture(): void;
7012 releaseEvents(): void;
7013 reloadWithHttpsOnlyException(): void;
7014 removeAnonymousContent(aContent: AnonymousContent): void;
7015 requestStorageAccess(): Promise<void>;
7016 requestStorageAccessForOrigin(thirdPartyOrigin: string, requireUserInteraction?: boolean): Promise<void>;
7017 requestStorageAccessUnderSite(serializedSite: string): Promise<void>;
7018 setKeyPressEventModel(aKeyPressEventModel: number): void;
7019 setNotifyFetchSuccess(aShouldNotify: boolean): void;
7020 setNotifyFormOrPasswordRemoved(aShouldNotify: boolean): void;
7021 setSuppressedEventListener(aListener: EventListener | null): void;
7022 userInteractionForTesting(): void;
7023 write(...text: string[]): void;
7024 writeln(...text: string[]): void;
7025 readonly KEYPRESS_EVENT_MODEL_DEFAULT: 0;
7026 readonly KEYPRESS_EVENT_MODEL_SPLIT: 1;
7027 readonly KEYPRESS_EVENT_MODEL_CONFLATED: 2;
7028 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7029 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7030 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7031 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7034 declare var Document: {
7035 prototype: Document;
7037 readonly KEYPRESS_EVENT_MODEL_DEFAULT: 0;
7038 readonly KEYPRESS_EVENT_MODEL_SPLIT: 1;
7039 readonly KEYPRESS_EVENT_MODEL_CONFLATED: 2;
7040 isInstance: IsInstance<Document>;
7041 parseHTMLUnsafe(html: string): Document;
7044 interface DocumentFragment extends Node, NonElementParentNode, ParentNode {
7047 declare var DocumentFragment: {
7048 prototype: DocumentFragment;
7049 new(): DocumentFragment;
7050 isInstance: IsInstance<DocumentFragment>;
7053 interface DocumentL10n extends DOMLocalization {
7054 readonly ready: Promise<any>;
7055 connectRoot(aElement: Node, aTranslate?: boolean): void;
7058 interface DocumentOrShadowRoot {
7059 readonly activeElement: Element | null;
7060 adoptedStyleSheets: CSSStyleSheet[];
7061 readonly fullscreenElement: Element | null;
7062 readonly mozFullScreenElement: Element | null;
7063 readonly pointerLockElement: Element | null;
7064 readonly styleSheets: StyleSheetList;
7065 elementFromPoint(x: number, y: number): Element | null;
7066 elementsFromPoint(x: number, y: number): Element[];
7067 getAnimations(): Animation[];
7068 nodeFromPoint(x: number, y: number): Node | null;
7069 nodesFromPoint(x: number, y: number): Node[];
7072 interface DocumentTimeline extends AnimationTimeline {
7075 declare var DocumentTimeline: {
7076 prototype: DocumentTimeline;
7077 new(options?: DocumentTimelineOptions): DocumentTimeline;
7078 isInstance: IsInstance<DocumentTimeline>;
7081 interface DocumentType extends Node, ChildNode {
7082 readonly name: string;
7083 readonly publicId: string;
7084 readonly systemId: string;
7087 declare var DocumentType: {
7088 prototype: DocumentType;
7089 new(): DocumentType;
7090 isInstance: IsInstance<DocumentType>;
7093 interface DominatorTree {
7094 readonly root: NodeId;
7095 getImmediateDominator(node: NodeId): NodeId | null;
7096 getImmediatelyDominated(node: NodeId): NodeId[] | null;
7097 getRetainedSize(node: NodeId): NodeSize | null;
7100 declare var DominatorTree: {
7101 prototype: DominatorTree;
7102 new(): DominatorTree;
7103 isInstance: IsInstance<DominatorTree>;
7106 interface DragEvent extends MouseEvent {
7107 readonly dataTransfer: DataTransfer | null;
7108 initDragEvent(type: string, canBubble?: boolean, cancelable?: boolean, aView?: Window | null, aDetail?: number, aScreenX?: number, aScreenY?: number, aClientX?: number, aClientY?: number, aCtrlKey?: boolean, aAltKey?: boolean, aShiftKey?: boolean, aMetaKey?: boolean, aButton?: number, aRelatedTarget?: EventTarget | null, aDataTransfer?: DataTransfer | null): void;
7111 declare var DragEvent: {
7112 prototype: DragEvent;
7113 new(type: string, eventInitDict?: DragEventInit): DragEvent;
7114 isInstance: IsInstance<DragEvent>;
7117 interface DynamicsCompressorNode extends AudioNode, AudioNodePassThrough {
7118 readonly attack: AudioParam;
7119 readonly knee: AudioParam;
7120 readonly ratio: AudioParam;
7121 readonly reduction: number;
7122 readonly release: AudioParam;
7123 readonly threshold: AudioParam;
7126 declare var DynamicsCompressorNode: {
7127 prototype: DynamicsCompressorNode;
7128 new(context: BaseAudioContext, options?: DynamicsCompressorOptions): DynamicsCompressorNode;
7129 isInstance: IsInstance<DynamicsCompressorNode>;
7132 interface EXT_blend_minmax {
7133 readonly MIN_EXT: 0x8007;
7134 readonly MAX_EXT: 0x8008;
7137 interface EXT_color_buffer_float {
7140 interface EXT_color_buffer_half_float {
7141 readonly RGBA16F_EXT: 0x881A;
7142 readonly RGB16F_EXT: 0x881B;
7143 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 0x8211;
7144 readonly UNSIGNED_NORMALIZED_EXT: 0x8C17;
7147 interface EXT_disjoint_timer_query {
7148 beginQueryEXT(target: GLenum, query: WebGLQuery): void;
7149 createQueryEXT(): WebGLQuery | null;
7150 deleteQueryEXT(query: WebGLQuery | null): void;
7151 endQueryEXT(target: GLenum): void;
7152 getQueryEXT(target: GLenum, pname: GLenum): any;
7153 getQueryObjectEXT(query: WebGLQuery, pname: GLenum): any;
7154 isQueryEXT(query: WebGLQuery | null): boolean;
7155 queryCounterEXT(query: WebGLQuery, target: GLenum): void;
7156 readonly QUERY_COUNTER_BITS_EXT: 0x8864;
7157 readonly CURRENT_QUERY_EXT: 0x8865;
7158 readonly QUERY_RESULT_EXT: 0x8866;
7159 readonly QUERY_RESULT_AVAILABLE_EXT: 0x8867;
7160 readonly TIME_ELAPSED_EXT: 0x88BF;
7161 readonly TIMESTAMP_EXT: 0x8E28;
7162 readonly GPU_DISJOINT_EXT: 0x8FBB;
7165 interface EXT_float_blend {
7168 interface EXT_frag_depth {
7171 interface EXT_sRGB {
7172 readonly SRGB_EXT: 0x8C40;
7173 readonly SRGB_ALPHA_EXT: 0x8C42;
7174 readonly SRGB8_ALPHA8_EXT: 0x8C43;
7175 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: 0x8210;
7178 interface EXT_shader_texture_lod {
7181 interface EXT_texture_compression_bptc {
7182 readonly COMPRESSED_RGBA_BPTC_UNORM_EXT: 0x8E8C;
7183 readonly COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: 0x8E8D;
7184 readonly COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: 0x8E8E;
7185 readonly COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: 0x8E8F;
7188 interface EXT_texture_compression_rgtc {
7189 readonly COMPRESSED_RED_RGTC1_EXT: 0x8DBB;
7190 readonly COMPRESSED_SIGNED_RED_RGTC1_EXT: 0x8DBC;
7191 readonly COMPRESSED_RED_GREEN_RGTC2_EXT: 0x8DBD;
7192 readonly COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 0x8DBE;
7195 interface EXT_texture_filter_anisotropic {
7196 readonly TEXTURE_MAX_ANISOTROPY_EXT: 0x84FE;
7197 readonly MAX_TEXTURE_MAX_ANISOTROPY_EXT: 0x84FF;
7200 interface EXT_texture_norm16 {
7201 readonly R16_EXT: 0x822A;
7202 readonly RG16_EXT: 0x822C;
7203 readonly RGB16_EXT: 0x8054;
7204 readonly RGBA16_EXT: 0x805B;
7205 readonly R16_SNORM_EXT: 0x8F98;
7206 readonly RG16_SNORM_EXT: 0x8F99;
7207 readonly RGB16_SNORM_EXT: 0x8F9A;
7208 readonly RGBA16_SNORM_EXT: 0x8F9B;
7211 interface ElementEventMap {
7212 "fullscreenchange": Event;
7213 "fullscreenerror": Event;
7216 interface Element extends Node, ARIAMixin, Animatable, ChildNode, GeometryUtils, NonDocumentTypeChildNode, ParentNode {
7217 readonly assignedSlot: HTMLSlotElement | null;
7218 readonly attributes: NamedNodeMap;
7219 readonly classList: DOMTokenList;
7221 readonly clientHeight: number;
7222 readonly clientHeightDouble: number;
7223 readonly clientLeft: number;
7224 readonly clientTop: number;
7225 readonly clientWidth: number;
7226 readonly clientWidthDouble: number;
7227 readonly currentCSSZoom: number;
7228 readonly firstLineBoxBSize: number;
7229 readonly fontSizeInflation: number;
7230 readonly hasVisibleScrollbars: boolean;
7232 readonly implementedPseudoElement: string | null;
7234 readonly localName: string;
7235 readonly namespaceURI: string | null;
7236 onfullscreenchange: ((this: Element, ev: Event) => any) | null;
7237 onfullscreenerror: ((this: Element, ev: Event) => any) | null;
7238 readonly openOrClosedAssignedSlot: HTMLSlotElement | null;
7239 readonly openOrClosedShadowRoot: ShadowRoot | null;
7241 readonly part: DOMTokenList;
7242 readonly prefix: string | null;
7243 readonly screen: nsIScreen | null;
7244 readonly screenX: number;
7245 readonly screenY: number;
7246 readonly scrollHeight: number;
7248 readonly scrollLeftMax: number;
7249 readonly scrollLeftMin: number;
7251 readonly scrollTopMax: number;
7252 readonly scrollTopMin: number;
7253 readonly scrollWidth: number;
7254 readonly shadowRoot: ShadowRoot | null;
7256 readonly tagName: string;
7257 attachShadow(shadowRootInitDict: ShadowRootInit): ShadowRoot;
7258 checkVisibility(options?: CheckVisibilityOptions): boolean;
7259 closest(selector: string): Element | null;
7260 getAsFlexContainer(): Flex | null;
7261 getAttribute(name: string): string | null;
7262 getAttributeNS(namespace: string | null, localName: string): string | null;
7263 getAttributeNames(): string[];
7264 getAttributeNode(name: string): Attr | null;
7265 getAttributeNodeNS(namespaceURI: string | null, localName: string): Attr | null;
7266 getBoundingClientRect(): DOMRect;
7267 getClientRects(): DOMRectList;
7268 getElementsByClassName(classNames: string): HTMLCollection;
7269 getElementsByTagName<K extends keyof HTMLElementTagNameMap>(localName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
7270 getElementsByTagName<K extends keyof SVGElementTagNameMap>(localName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
7271 getElementsByTagName<K extends keyof MathMLElementTagNameMap>(localName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
7273 getElementsByTagName<K extends keyof HTMLElementDeprecatedTagNameMap>(localName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
7274 getElementsByTagName(localName: string): HTMLCollectionOf<Element>;
7275 getElementsByTagNameNS(namespace: string | null, localName: string): HTMLCollection;
7276 getElementsWithGrid(): Element[];
7277 getGridFragments(): Grid[];
7278 getHTML(options?: GetHTMLOptions): string;
7279 getTransformToAncestor(ancestor: Element): DOMMatrixReadOnly;
7280 getTransformToParent(): DOMMatrixReadOnly;
7281 getTransformToViewport(): DOMMatrixReadOnly;
7282 hasAttribute(name: string): boolean;
7283 hasAttributeNS(namespace: string | null, localName: string): boolean;
7284 hasAttributes(): boolean;
7285 hasGridFragments(): boolean;
7286 hasPointerCapture(pointerId: number): boolean;
7287 insertAdjacentElement(where: string, element: Element): Element | null;
7288 insertAdjacentHTML(position: string, text: string): void;
7289 insertAdjacentText(where: string, data: string): void;
7290 matches(selector: string): boolean;
7291 mozMatchesSelector(selector: string): boolean;
7292 mozRequestFullScreen(): Promise<void>;
7293 mozScrollSnap(): void;
7294 releaseCapture(): void;
7295 releasePointerCapture(pointerId: number): void;
7296 removeAttribute(name: string): void;
7297 removeAttributeNS(namespace: string | null, localName: string): void;
7298 removeAttributeNode(oldAttr: Attr): Attr | null;
7299 requestFullscreen(): Promise<void>;
7300 requestPointerLock(): void;
7301 scroll(x: number, y: number): void;
7302 scroll(options?: ScrollToOptions): void;
7303 scrollBy(x: number, y: number): void;
7304 scrollBy(options?: ScrollToOptions): void;
7305 scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
7306 scrollTo(x: number, y: number): void;
7307 scrollTo(options?: ScrollToOptions): void;
7308 setAttribute(name: string, value: string): void;
7309 setAttributeDevtools(name: string, value: string): void;
7310 setAttributeDevtoolsNS(namespace: string | null, name: string, value: string): void;
7311 setAttributeNS(namespace: string | null, name: string, value: string): void;
7312 setAttributeNode(newAttr: Attr): Attr | null;
7313 setAttributeNodeNS(newAttr: Attr): Attr | null;
7314 setCapture(retargetToElement?: boolean): void;
7315 setCaptureAlways(retargetToElement?: boolean): void;
7316 /** Available only in secure contexts. */
7317 setHTML(aInnerHTML: string, options?: SetHTMLOptions): void;
7318 setHTMLUnsafe(html: string): void;
7319 setPointerCapture(pointerId: number): void;
7320 toggleAttribute(name: string, force?: boolean): boolean;
7321 webkitMatchesSelector(selector: string): boolean;
7322 addEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7323 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7324 removeEventListener<K extends keyof ElementEventMap>(type: K, listener: (this: Element, ev: ElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7325 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7328 declare var Element: {
7331 isInstance: IsInstance<Element>;
7334 interface ElementCSSInlineStyle {
7335 readonly style: CSSStyleDeclaration;
7338 interface ElementInternals extends ARIAMixin {
7339 readonly form: HTMLFormElement | null;
7340 readonly labels: NodeList;
7341 readonly shadowRoot: ShadowRoot | null;
7342 readonly states: CustomStateSet;
7343 readonly validationAnchor: HTMLElement | null;
7344 readonly validationMessage: string;
7345 readonly validity: ValidityState;
7346 readonly willValidate: boolean;
7347 checkValidity(): boolean;
7348 reportValidity(): boolean;
7349 setFormValue(value: File | string | FormData | null, state?: File | string | FormData | null): void;
7350 setValidity(flags?: ValidityStateFlags, message?: string, anchor?: HTMLElement): void;
7353 declare var ElementInternals: {
7354 prototype: ElementInternals;
7355 new(): ElementInternals;
7356 isInstance: IsInstance<ElementInternals>;
7359 interface EncodedAudioChunk {
7360 readonly byteLength: number;
7361 readonly duration: number | null;
7362 readonly timestamp: number;
7363 readonly type: EncodedAudioChunkType;
7364 copyTo(destination: ArrayBufferView | ArrayBuffer): void;
7367 declare var EncodedAudioChunk: {
7368 prototype: EncodedAudioChunk;
7369 new(init: EncodedAudioChunkInit): EncodedAudioChunk;
7370 isInstance: IsInstance<EncodedAudioChunk>;
7373 interface EncodedVideoChunk {
7374 readonly byteLength: number;
7375 readonly duration: number | null;
7376 readonly timestamp: number;
7377 readonly type: EncodedVideoChunkType;
7378 copyTo(destination: ArrayBufferView | ArrayBuffer): void;
7381 declare var EncodedVideoChunk: {
7382 prototype: EncodedVideoChunk;
7383 new(init: EncodedVideoChunkInit): EncodedVideoChunk;
7384 isInstance: IsInstance<EncodedVideoChunk>;
7387 interface ErrorEvent extends Event {
7388 readonly colno: number;
7389 readonly error: any;
7390 readonly filename: string;
7391 readonly lineno: number;
7392 readonly message: string;
7395 declare var ErrorEvent: {
7396 prototype: ErrorEvent;
7397 new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
7398 isInstance: IsInstance<ErrorEvent>;
7402 readonly bubbles: boolean;
7403 cancelBubble: boolean;
7404 readonly cancelable: boolean;
7405 readonly composed: boolean;
7406 readonly composedTarget: EventTarget | null;
7407 readonly currentTarget: EventTarget | null;
7408 readonly defaultPrevented: boolean;
7409 readonly defaultPreventedByChrome: boolean;
7410 readonly defaultPreventedByContent: boolean;
7411 readonly eventPhase: number;
7412 readonly explicitOriginalTarget: EventTarget | null;
7413 readonly isReplyEventFromRemoteContent: boolean;
7414 readonly isSynthesized: boolean;
7415 readonly isTrusted: boolean;
7416 readonly isWaitingReplyFromRemoteContent: boolean;
7417 readonly multipleActionsPrevented: boolean;
7418 readonly originalTarget: EventTarget | null;
7419 returnValue: boolean;
7420 readonly target: EventTarget | null;
7421 readonly timeStamp: DOMHighResTimeStamp;
7422 readonly type: string;
7423 composedPath(): EventTarget[];
7424 initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
7425 preventDefault(): void;
7426 preventMultipleActions(): void;
7427 requestReplyFromRemoteContent(): void;
7428 stopImmediatePropagation(): void;
7429 stopPropagation(): void;
7431 readonly CAPTURING_PHASE: 1;
7432 readonly AT_TARGET: 2;
7433 readonly BUBBLING_PHASE: 3;
7434 readonly ALT_MASK: 0x00000001;
7435 readonly CONTROL_MASK: 0x00000002;
7436 readonly SHIFT_MASK: 0x00000004;
7437 readonly META_MASK: 0x00000008;
7440 declare var Event: {
7442 new(type: string, eventInitDict?: EventInit): Event;
7444 readonly CAPTURING_PHASE: 1;
7445 readonly AT_TARGET: 2;
7446 readonly BUBBLING_PHASE: 3;
7447 readonly ALT_MASK: 0x00000001;
7448 readonly CONTROL_MASK: 0x00000002;
7449 readonly SHIFT_MASK: 0x00000004;
7450 readonly META_MASK: 0x00000008;
7451 isInstance: IsInstance<Event>;
7454 interface EventCallbackDebuggerNotification extends CallbackDebuggerNotification {
7455 readonly event: Event;
7456 readonly targetType: EventCallbackDebuggerNotificationType;
7459 declare var EventCallbackDebuggerNotification: {
7460 prototype: EventCallbackDebuggerNotification;
7461 new(): EventCallbackDebuggerNotification;
7462 isInstance: IsInstance<EventCallbackDebuggerNotification>;
7465 interface EventCounts {
7466 forEach(callbackfn: (value: number, key: string, parent: EventCounts) => void, thisArg?: any): void;
7469 declare var EventCounts: {
7470 prototype: EventCounts;
7472 isInstance: IsInstance<EventCounts>;
7475 interface EventHandler {
7478 interface EventListenerOrEventListenerObject {
7481 interface EventSourceEventMap {
7487 interface EventSource extends EventTarget {
7488 onerror: ((this: EventSource, ev: Event) => any) | null;
7489 onmessage: ((this: EventSource, ev: Event) => any) | null;
7490 onopen: ((this: EventSource, ev: Event) => any) | null;
7491 readonly readyState: number;
7492 readonly url: string;
7493 readonly withCredentials: boolean;
7495 readonly CONNECTING: 0;
7498 addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7499 addEventListener(type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
7500 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7501 removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7502 removeEventListener(type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | EventListenerOptions): void;
7503 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7506 declare var EventSource: {
7507 prototype: EventSource;
7508 new(url: string | URL, eventSourceInitDict?: EventSourceInit): EventSource;
7509 readonly CONNECTING: 0;
7512 isInstance: IsInstance<EventSource>;
7515 interface EventTarget {
7516 readonly ownerGlobal: WindowProxy | null;
7517 addEventListener(type: string, listener: EventListener | null, options?: AddEventListenerOptions | boolean, wantsUntrusted?: boolean | null): void;
7518 dispatchEvent(event: Event): boolean;
7519 getEventHandler(type: string): EventHandler;
7520 removeEventListener(type: string, listener: EventListener | null, options?: EventListenerOptions | boolean): void;
7521 setEventHandler(type: string, handler: EventHandler): void;
7524 declare var EventTarget: {
7525 prototype: EventTarget;
7527 isInstance: IsInstance<EventTarget>;
7530 interface Exception extends ExceptionMembers {
7531 readonly message: string;
7532 readonly name: string;
7536 interface ExceptionMembers {
7537 readonly columnNumber: number;
7538 readonly data: nsISupports | null;
7539 readonly filename: string;
7540 readonly lineNumber: number;
7541 readonly location: StackFrame | null;
7542 readonly result: number;
7543 readonly stack: string;
7546 interface External {
7547 AddSearchProvider(): void;
7548 IsSearchProviderInstalled(): void;
7551 interface FeaturePolicy {
7552 allowedFeatures(): string[];
7553 allowsFeature(feature: string, origin?: string): boolean;
7554 features(): string[];
7555 getAllowlistForFeature(feature: string): string[];
7558 interface FeaturePolicyViolationReportBody extends ReportBody {
7559 readonly columnNumber: number | null;
7560 readonly disposition: string;
7561 readonly featureId: string;
7562 readonly lineNumber: number | null;
7563 readonly sourceFile: string | null;
7566 declare var FeaturePolicyViolationReportBody: {
7567 prototype: FeaturePolicyViolationReportBody;
7568 new(): FeaturePolicyViolationReportBody;
7569 isInstance: IsInstance<FeaturePolicyViolationReportBody>;
7572 interface FetchObserverEventMap {
7573 "requestprogress": Event;
7574 "responseprogress": Event;
7575 "statechange": Event;
7578 interface FetchObserver extends EventTarget {
7579 onrequestprogress: ((this: FetchObserver, ev: Event) => any) | null;
7580 onresponseprogress: ((this: FetchObserver, ev: Event) => any) | null;
7581 onstatechange: ((this: FetchObserver, ev: Event) => any) | null;
7582 readonly state: FetchState;
7583 addEventListener<K extends keyof FetchObserverEventMap>(type: K, listener: (this: FetchObserver, ev: FetchObserverEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7584 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7585 removeEventListener<K extends keyof FetchObserverEventMap>(type: K, listener: (this: FetchObserver, ev: FetchObserverEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7586 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7589 declare var FetchObserver: {
7590 prototype: FetchObserver;
7591 new(): FetchObserver;
7592 isInstance: IsInstance<FetchObserver>;
7595 interface File extends Blob {
7596 readonly lastModified: number;
7597 readonly mozFullPath: string;
7598 readonly name: string;
7599 readonly webkitRelativePath: string;
7604 new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
7605 isInstance: IsInstance<File>;
7606 createFromFileName(fileName: string, options?: ChromeFilePropertyBag): Promise<File>;
7607 createFromNsIFile(file: nsIFile, options?: ChromeFilePropertyBag): Promise<File>;
7610 interface FileList {
7611 readonly length: number;
7612 item(index: number): File | null;
7613 [index: number]: File;
7616 declare var FileList: {
7617 prototype: FileList;
7619 isInstance: IsInstance<FileList>;
7622 interface FileReaderEventMap {
7631 interface FileReader extends EventTarget {
7632 readonly error: DOMException | null;
7633 onabort: ((this: FileReader, ev: Event) => any) | null;
7634 onerror: ((this: FileReader, ev: Event) => any) | null;
7635 onload: ((this: FileReader, ev: Event) => any) | null;
7636 onloadend: ((this: FileReader, ev: Event) => any) | null;
7637 onloadstart: ((this: FileReader, ev: Event) => any) | null;
7638 onprogress: ((this: FileReader, ev: Event) => any) | null;
7639 readonly readyState: number;
7640 readonly result: string | ArrayBuffer | null;
7642 readAsArrayBuffer(blob: Blob): void;
7643 readAsBinaryString(filedata: Blob): void;
7644 readAsDataURL(blob: Blob): void;
7645 readAsText(blob: Blob, label?: string): void;
7647 readonly LOADING: 1;
7649 addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7650 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7651 removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7652 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7655 declare var FileReader: {
7656 prototype: FileReader;
7659 readonly LOADING: 1;
7661 isInstance: IsInstance<FileReader>;
7664 interface FileSystem {
7665 readonly name: string;
7666 readonly root: FileSystemDirectoryEntry;
7669 declare var FileSystem: {
7670 prototype: FileSystem;
7672 isInstance: IsInstance<FileSystem>;
7675 interface FileSystemDirectoryEntry extends FileSystemEntry {
7676 createReader(): FileSystemDirectoryReader;
7677 getDirectory(path?: string | null, options?: FileSystemFlags, successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
7678 getFile(path?: string | null, options?: FileSystemFlags, successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
7681 declare var FileSystemDirectoryEntry: {
7682 prototype: FileSystemDirectoryEntry;
7683 new(): FileSystemDirectoryEntry;
7684 isInstance: IsInstance<FileSystemDirectoryEntry>;
7687 /** Available only in secure contexts. */
7688 interface FileSystemDirectoryHandle extends FileSystemHandle {
7689 getDirectoryHandle(name: string, options?: FileSystemGetDirectoryOptions): Promise<FileSystemDirectoryHandle>;
7690 getFileHandle(name: string, options?: FileSystemGetFileOptions): Promise<FileSystemFileHandle>;
7691 removeEntry(name: string, options?: FileSystemRemoveOptions): Promise<void>;
7692 resolve(possibleDescendant: FileSystemHandle): Promise<string[] | null>;
7695 declare var FileSystemDirectoryHandle: {
7696 prototype: FileSystemDirectoryHandle;
7697 new(): FileSystemDirectoryHandle;
7698 isInstance: IsInstance<FileSystemDirectoryHandle>;
7701 /** Available only in secure contexts. */
7702 interface FileSystemDirectoryIterator {
7703 next(): Promise<any>;
7706 interface FileSystemDirectoryReader {
7707 readEntries(successCallback: FileSystemEntriesCallback, errorCallback?: ErrorCallback): void;
7710 declare var FileSystemDirectoryReader: {
7711 prototype: FileSystemDirectoryReader;
7712 new(): FileSystemDirectoryReader;
7713 isInstance: IsInstance<FileSystemDirectoryReader>;
7716 interface FileSystemEntry {
7717 readonly filesystem: FileSystem;
7718 readonly fullPath: string;
7719 readonly isDirectory: boolean;
7720 readonly isFile: boolean;
7721 readonly name: string;
7722 getParent(successCallback?: FileSystemEntryCallback, errorCallback?: ErrorCallback): void;
7725 declare var FileSystemEntry: {
7726 prototype: FileSystemEntry;
7727 new(): FileSystemEntry;
7728 isInstance: IsInstance<FileSystemEntry>;
7731 interface FileSystemFileEntry extends FileSystemEntry {
7732 file(successCallback: FileCallback, errorCallback?: ErrorCallback): void;
7735 declare var FileSystemFileEntry: {
7736 prototype: FileSystemFileEntry;
7737 new(): FileSystemFileEntry;
7738 isInstance: IsInstance<FileSystemFileEntry>;
7741 /** Available only in secure contexts. */
7742 interface FileSystemFileHandle extends FileSystemHandle {
7743 createWritable(options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
7744 getFile(): Promise<File>;
7747 declare var FileSystemFileHandle: {
7748 prototype: FileSystemFileHandle;
7749 new(): FileSystemFileHandle;
7750 isInstance: IsInstance<FileSystemFileHandle>;
7753 /** Available only in secure contexts. */
7754 interface FileSystemHandle {
7755 readonly kind: FileSystemHandleKind;
7756 readonly name: string;
7757 isSameEntry(other: FileSystemHandle): Promise<boolean>;
7758 move(name: string): Promise<void>;
7759 move(parent: FileSystemDirectoryHandle): Promise<void>;
7760 move(parent: FileSystemDirectoryHandle, name: string): Promise<void>;
7763 declare var FileSystemHandle: {
7764 prototype: FileSystemHandle;
7765 new(): FileSystemHandle;
7766 isInstance: IsInstance<FileSystemHandle>;
7769 /** Available only in secure contexts. */
7770 interface FileSystemWritableFileStream extends WritableStream {
7771 seek(position: number): Promise<void>;
7772 truncate(size: number): Promise<void>;
7773 write(data: FileSystemWriteChunkType): Promise<void>;
7776 declare var FileSystemWritableFileStream: {
7777 prototype: FileSystemWritableFileStream;
7778 new(): FileSystemWritableFileStream;
7779 isInstance: IsInstance<FileSystemWritableFileStream>;
7783 readonly crossAxisDirection: FlexPhysicalDirection;
7784 readonly mainAxisDirection: FlexPhysicalDirection;
7785 getLines(): FlexLineValues[];
7791 isInstance: IsInstance<Flex>;
7794 interface FlexItemValues {
7795 readonly clampState: FlexItemClampState;
7796 readonly crossMaxSize: number;
7797 readonly crossMinSize: number;
7798 readonly frameRect: DOMRectReadOnly;
7799 readonly mainBaseSize: number;
7800 readonly mainDeltaSize: number;
7801 readonly mainMaxSize: number;
7802 readonly mainMinSize: number;
7803 readonly node: Node | null;
7806 declare var FlexItemValues: {
7807 prototype: FlexItemValues;
7808 new(): FlexItemValues;
7809 isInstance: IsInstance<FlexItemValues>;
7812 interface FlexLineValues {
7813 readonly crossSize: number;
7814 readonly crossStart: number;
7815 readonly firstBaselineOffset: number;
7816 readonly growthState: FlexLineGrowthState;
7817 readonly lastBaselineOffset: number;
7818 getItems(): FlexItemValues[];
7821 declare var FlexLineValues: {
7822 prototype: FlexLineValues;
7823 new(): FlexLineValues;
7824 isInstance: IsInstance<FlexLineValues>;
7827 interface FluentBundle {
7828 readonly locales: string[];
7829 addResource(aResource: FluentResource, aOptions?: FluentBundleAddResourceOptions): void;
7830 formatPattern(pattern: FluentPattern, aArgs?: L10nArgs | null, aErrors?: any): string;
7831 getMessage(id: string): FluentMessage | null;
7832 hasMessage(id: string): boolean;
7835 declare var FluentBundle: {
7836 prototype: FluentBundle;
7837 new(aLocales: string | string[], aOptions?: FluentBundleOptions): FluentBundle;
7838 isInstance: IsInstance<FluentBundle>;
7841 interface FluentBundleAsyncIterator {
7842 next(): Promise<FluentBundleIteratorResult>;
7843 values(): FluentBundleAsyncIterator;
7846 interface FluentBundleIterator {
7847 next(): FluentBundleIteratorResult;
7848 values(): FluentBundleIterator;
7851 interface FluentPattern {
7854 declare var FluentPattern: {
7855 prototype: FluentPattern;
7856 new(): FluentPattern;
7857 isInstance: IsInstance<FluentPattern>;
7860 interface FluentResource {
7861 textElements(): FluentTextElementItem[];
7864 declare var FluentResource: {
7865 prototype: FluentResource;
7866 new(source: string): FluentResource;
7867 isInstance: IsInstance<FluentResource>;
7870 interface FocusEvent extends UIEvent {
7871 readonly relatedTarget: EventTarget | null;
7874 declare var FocusEvent: {
7875 prototype: FocusEvent;
7876 new(typeArg: string, focusEventInitDict?: FocusEventInit): FocusEvent;
7877 isInstance: IsInstance<FocusEvent>;
7880 interface FontFace {
7881 ascentOverride: string;
7882 descentOverride: string;
7885 featureSettings: string;
7886 lineGapOverride: string;
7887 readonly loaded: Promise<FontFace>;
7889 readonly status: FontFaceLoadStatus;
7892 unicodeRange: string;
7894 variationSettings: string;
7896 load(): Promise<FontFace>;
7899 declare var FontFace: {
7900 prototype: FontFace;
7901 new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace;
7902 isInstance: IsInstance<FontFace>;
7905 interface FontFaceSetEventMap {
7907 "loadingdone": Event;
7908 "loadingerror": Event;
7911 interface FontFaceSet extends EventTarget {
7912 onloading: ((this: FontFaceSet, ev: Event) => any) | null;
7913 onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null;
7914 onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null;
7915 readonly ready: Promise<undefined>;
7916 readonly size: number;
7917 readonly status: FontFaceSetLoadStatus;
7918 add(font: FontFace): void;
7919 check(font: string, text?: string): boolean;
7921 delete(font: FontFace): boolean;
7922 entries(): FontFaceSetIterator;
7923 forEach(cb: FontFaceSetForEachCallback, thisArg?: any): void;
7924 has(font: FontFace): boolean;
7925 load(font: string, text?: string): Promise<FontFace[]>;
7926 values(): FontFaceSetIterator;
7927 addEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
7928 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
7929 removeEventListener<K extends keyof FontFaceSetEventMap>(type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
7930 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
7933 declare var FontFaceSet: {
7934 prototype: FontFaceSet;
7936 isInstance: IsInstance<FontFaceSet>;
7939 interface FontFaceSetIterator {
7940 next(): FontFaceSetIteratorResult;
7943 interface FontFaceSetLoadEvent extends Event {
7944 readonly fontfaces: FontFace[];
7947 declare var FontFaceSetLoadEvent: {
7948 prototype: FontFaceSetLoadEvent;
7949 new(type: string, eventInitDict?: FontFaceSetLoadEventInit): FontFaceSetLoadEvent;
7950 isInstance: IsInstance<FontFaceSetLoadEvent>;
7953 interface FontFaceSource {
7954 readonly fonts: FontFaceSet;
7957 interface FormData {
7958 append(name: string, value: Blob, filename?: string): void;
7959 append(name: string, value: string): void;
7960 delete(name: string): void;
7961 get(name: string): FormDataEntryValue | null;
7962 getAll(name: string): FormDataEntryValue[];
7963 has(name: string): boolean;
7964 set(name: string, value: Blob, filename?: string): void;
7965 set(name: string, value: string): void;
7966 forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
7969 declare var FormData: {
7970 prototype: FormData;
7971 new(form?: HTMLFormElement, submitter?: HTMLElement | null): FormData;
7972 isInstance: IsInstance<FormData>;
7975 interface FormDataEvent extends Event {
7976 readonly formData: FormData;
7979 declare var FormDataEvent: {
7980 prototype: FormDataEvent;
7981 new(type: string, eventInitDict?: FormDataEventInit): FormDataEvent;
7982 isInstance: IsInstance<FormDataEvent>;
7985 interface FragmentDirective {
7988 declare var FragmentDirective: {
7989 prototype: FragmentDirective;
7990 new(): FragmentDirective;
7991 isInstance: IsInstance<FragmentDirective>;
7994 interface FrameCrashedEvent extends Event {
7995 readonly browsingContextId: number;
7996 readonly childID: number;
7997 readonly isTopFrame: boolean;
8000 declare var FrameCrashedEvent: {
8001 prototype: FrameCrashedEvent;
8002 new(type: string, eventInitDict?: FrameCrashedEventInit): FrameCrashedEvent;
8003 isInstance: IsInstance<FrameCrashedEvent>;
8006 interface FrameLoader extends WebBrowserPersistable {
8007 readonly browsingContext: BrowsingContext | null;
8008 readonly childID: number;
8009 readonly depthTooGreat: boolean;
8010 readonly docShell: nsIDocShell | null;
8011 readonly isDead: boolean;
8012 readonly isRemoteFrame: boolean;
8013 readonly lazyHeight: number;
8014 readonly lazyWidth: number;
8015 readonly loadContext: LoadContext | null;
8016 readonly messageManager: MessageSender | null;
8017 readonly ownerElement: Element | null;
8018 readonly remoteTab: RemoteTab | null;
8019 exitPrintPreview(): void;
8020 printPreview(aPrintSettings: nsIPrintSettings, aSourceBrowsingContext: BrowsingContext | null): Promise<number>;
8021 requestEpochUpdate(aEpoch: number): void;
8022 requestSHistoryUpdate(): void;
8023 requestTabStateFlush(): Promise<void>;
8024 requestUpdatePosition(): void;
8027 declare var FrameLoader: {
8028 prototype: FrameLoader;
8030 isInstance: IsInstance<FrameLoader>;
8033 interface FrameScriptLoader {
8034 getDelayedFrameScripts(): any[][];
8035 loadFrameScript(url: string, allowDelayedLoad: boolean, runInGlobalScope?: boolean): void;
8036 removeDelayedFrameScript(url: string): void;
8039 /** Available only in secure contexts. */
8041 getPreferredCanvasFormat(): GPUTextureFormat;
8042 requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | null>;
8048 isInstance: IsInstance<GPU>;
8051 /** Available only in secure contexts. */
8052 interface GPUAdapter {
8053 readonly features: GPUSupportedFeatures;
8054 readonly isFallbackAdapter: boolean;
8055 readonly limits: GPUSupportedLimits;
8056 requestAdapterInfo(unmaskHints?: string[]): Promise<GPUAdapterInfo>;
8057 requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
8060 declare var GPUAdapter: {
8061 prototype: GPUAdapter;
8063 isInstance: IsInstance<GPUAdapter>;
8066 /** Available only in secure contexts. */
8067 interface GPUAdapterInfo {
8068 readonly architecture: string;
8069 readonly description: string;
8070 readonly device: string;
8071 readonly vendor: string;
8072 readonly wgpuBackend: string;
8073 readonly wgpuDevice: number;
8074 readonly wgpuDeviceType: string;
8075 readonly wgpuDriver: string;
8076 readonly wgpuDriverInfo: string;
8077 readonly wgpuName: string;
8078 readonly wgpuVendor: number;
8081 declare var GPUAdapterInfo: {
8082 prototype: GPUAdapterInfo;
8083 new(): GPUAdapterInfo;
8084 isInstance: IsInstance<GPUAdapterInfo>;
8087 /** Available only in secure contexts. */
8088 interface GPUBindGroup extends GPUObjectBase {
8091 declare var GPUBindGroup: {
8092 prototype: GPUBindGroup;
8093 new(): GPUBindGroup;
8094 isInstance: IsInstance<GPUBindGroup>;
8097 /** Available only in secure contexts. */
8098 interface GPUBindGroupLayout extends GPUObjectBase {
8101 declare var GPUBindGroupLayout: {
8102 prototype: GPUBindGroupLayout;
8103 new(): GPUBindGroupLayout;
8104 isInstance: IsInstance<GPUBindGroupLayout>;
8107 interface GPUBindingCommandsMixin {
8108 setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: GPUBufferDynamicOffset[]): void;
8111 /** Available only in secure contexts. */
8112 interface GPUBuffer extends GPUObjectBase {
8113 readonly mapState: GPUBufferMapState;
8114 readonly size: GPUSize64Out;
8115 readonly usage: GPUFlagsConstant;
8117 getMappedRange(offset?: GPUSize64, size?: GPUSize64): ArrayBuffer;
8118 mapAsync(mode: GPUMapModeFlags, offset?: GPUSize64, size?: GPUSize64): Promise<void>;
8122 declare var GPUBuffer: {
8123 prototype: GPUBuffer;
8125 isInstance: IsInstance<GPUBuffer>;
8128 /** Available only in secure contexts. */
8129 interface GPUBufferUsage {
8130 readonly MAP_READ: 0x0001;
8131 readonly MAP_WRITE: 0x0002;
8132 readonly COPY_SRC: 0x0004;
8133 readonly COPY_DST: 0x0008;
8134 readonly INDEX: 0x0010;
8135 readonly VERTEX: 0x0020;
8136 readonly UNIFORM: 0x0040;
8137 readonly STORAGE: 0x0080;
8138 readonly INDIRECT: 0x0100;
8139 readonly QUERY_RESOLVE: 0x0200;
8142 declare var GPUBufferUsage: {
8143 prototype: GPUBufferUsage;
8144 new(): GPUBufferUsage;
8145 readonly MAP_READ: 0x0001;
8146 readonly MAP_WRITE: 0x0002;
8147 readonly COPY_SRC: 0x0004;
8148 readonly COPY_DST: 0x0008;
8149 readonly INDEX: 0x0010;
8150 readonly VERTEX: 0x0020;
8151 readonly UNIFORM: 0x0040;
8152 readonly STORAGE: 0x0080;
8153 readonly INDIRECT: 0x0100;
8154 readonly QUERY_RESOLVE: 0x0200;
8155 isInstance: IsInstance<GPUBufferUsage>;
8158 /** Available only in secure contexts. */
8159 interface GPUCanvasContext {
8160 readonly canvas: HTMLCanvasElement | OffscreenCanvas;
8161 configure(configuration: GPUCanvasConfiguration): void;
8162 getCurrentTexture(): GPUTexture;
8163 unconfigure(): void;
8166 declare var GPUCanvasContext: {
8167 prototype: GPUCanvasContext;
8168 new(): GPUCanvasContext;
8169 isInstance: IsInstance<GPUCanvasContext>;
8172 /** Available only in secure contexts. */
8173 interface GPUColorWrite {
8175 readonly GREEN: 0x2;
8177 readonly ALPHA: 0x8;
8181 declare var GPUColorWrite: {
8182 prototype: GPUColorWrite;
8183 new(): GPUColorWrite;
8185 readonly GREEN: 0x2;
8187 readonly ALPHA: 0x8;
8189 isInstance: IsInstance<GPUColorWrite>;
8192 /** Available only in secure contexts. */
8193 interface GPUCommandBuffer extends GPUObjectBase {
8196 declare var GPUCommandBuffer: {
8197 prototype: GPUCommandBuffer;
8198 new(): GPUCommandBuffer;
8199 isInstance: IsInstance<GPUCommandBuffer>;
8202 /** Available only in secure contexts. */
8203 interface GPUCommandEncoder extends GPUDebugCommandsMixin, GPUObjectBase {
8204 beginComputePass(descriptor?: GPUComputePassDescriptor): GPUComputePassEncoder;
8205 beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
8206 clearBuffer(buffer: GPUBuffer, offset?: GPUSize64, size?: GPUSize64): void;
8207 copyBufferToBuffer(source: GPUBuffer, sourceOffset: GPUSize64, destination: GPUBuffer, destinationOffset: GPUSize64, size: GPUSize64): void;
8208 copyBufferToTexture(source: GPUImageCopyBuffer, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
8209 copyTextureToBuffer(source: GPUImageCopyTexture, destination: GPUImageCopyBuffer, copySize: GPUExtent3D): void;
8210 copyTextureToTexture(source: GPUImageCopyTexture, destination: GPUImageCopyTexture, copySize: GPUExtent3D): void;
8211 finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
8214 declare var GPUCommandEncoder: {
8215 prototype: GPUCommandEncoder;
8216 new(): GPUCommandEncoder;
8217 isInstance: IsInstance<GPUCommandEncoder>;
8220 /** Available only in secure contexts. */
8221 interface GPUCompilationInfo {
8222 readonly messages: GPUCompilationMessage[];
8225 declare var GPUCompilationInfo: {
8226 prototype: GPUCompilationInfo;
8227 new(): GPUCompilationInfo;
8228 isInstance: IsInstance<GPUCompilationInfo>;
8231 /** Available only in secure contexts. */
8232 interface GPUCompilationMessage {
8233 readonly length: number;
8234 readonly lineNum: number;
8235 readonly linePos: number;
8236 readonly message: string;
8237 readonly offset: number;
8238 readonly type: GPUCompilationMessageType;
8241 declare var GPUCompilationMessage: {
8242 prototype: GPUCompilationMessage;
8243 new(): GPUCompilationMessage;
8244 isInstance: IsInstance<GPUCompilationMessage>;
8247 /** Available only in secure contexts. */
8248 interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase {
8249 dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void;
8250 dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
8252 setPipeline(pipeline: GPUComputePipeline): void;
8255 declare var GPUComputePassEncoder: {
8256 prototype: GPUComputePassEncoder;
8257 new(): GPUComputePassEncoder;
8258 isInstance: IsInstance<GPUComputePassEncoder>;
8261 /** Available only in secure contexts. */
8262 interface GPUComputePipeline extends GPUObjectBase, GPUPipelineBase {
8265 declare var GPUComputePipeline: {
8266 prototype: GPUComputePipeline;
8267 new(): GPUComputePipeline;
8268 isInstance: IsInstance<GPUComputePipeline>;
8271 interface GPUDebugCommandsMixin {
8272 insertDebugMarker(markerLabel: string): void;
8273 popDebugGroup(): void;
8274 pushDebugGroup(groupLabel: string): void;
8277 interface GPUDeviceEventMap {
8278 "uncapturederror": Event;
8281 /** Available only in secure contexts. */
8282 interface GPUDevice extends EventTarget, GPUObjectBase {
8283 readonly features: GPUSupportedFeatures;
8284 readonly limits: GPUSupportedLimits;
8285 readonly lost: Promise<GPUDeviceLostInfo>;
8286 onuncapturederror: ((this: GPUDevice, ev: Event) => any) | null;
8287 readonly queue: GPUQueue;
8288 createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
8289 createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): GPUBindGroupLayout;
8290 createBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
8291 createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder;
8292 createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline;
8293 createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
8294 createPipelineLayout(descriptor: GPUPipelineLayoutDescriptor): GPUPipelineLayout;
8295 createRenderBundleEncoder(descriptor: GPURenderBundleEncoderDescriptor): GPURenderBundleEncoder;
8296 createRenderPipeline(descriptor: GPURenderPipelineDescriptor): GPURenderPipeline;
8297 createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
8298 createSampler(descriptor?: GPUSamplerDescriptor): GPUSampler;
8299 createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
8300 createTexture(descriptor: GPUTextureDescriptor): GPUTexture;
8302 popErrorScope(): Promise<GPUError | null>;
8303 pushErrorScope(filter: GPUErrorFilter): void;
8304 addEventListener<K extends keyof GPUDeviceEventMap>(type: K, listener: (this: GPUDevice, ev: GPUDeviceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
8305 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
8306 removeEventListener<K extends keyof GPUDeviceEventMap>(type: K, listener: (this: GPUDevice, ev: GPUDeviceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
8307 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
8310 declare var GPUDevice: {
8311 prototype: GPUDevice;
8313 isInstance: IsInstance<GPUDevice>;
8316 /** Available only in secure contexts. */
8317 interface GPUDeviceLostInfo {
8318 readonly message: string;
8319 readonly reason: any;
8322 declare var GPUDeviceLostInfo: {
8323 prototype: GPUDeviceLostInfo;
8324 new(): GPUDeviceLostInfo;
8325 isInstance: IsInstance<GPUDeviceLostInfo>;
8328 /** Available only in secure contexts. */
8329 interface GPUError {
8330 readonly message: string;
8333 declare var GPUError: {
8334 prototype: GPUError;
8336 isInstance: IsInstance<GPUError>;
8339 /** Available only in secure contexts. */
8340 interface GPUInternalError extends GPUError {
8343 declare var GPUInternalError: {
8344 prototype: GPUInternalError;
8345 new(message: string): GPUInternalError;
8346 isInstance: IsInstance<GPUInternalError>;
8349 /** Available only in secure contexts. */
8350 interface GPUMapMode {
8351 readonly READ: 0x0001;
8352 readonly WRITE: 0x0002;
8355 declare var GPUMapMode: {
8356 prototype: GPUMapMode;
8358 readonly READ: 0x0001;
8359 readonly WRITE: 0x0002;
8360 isInstance: IsInstance<GPUMapMode>;
8363 interface GPUObjectBase {
8364 label: string | null;
8367 /** Available only in secure contexts. */
8368 interface GPUOutOfMemoryError extends GPUError {
8371 declare var GPUOutOfMemoryError: {
8372 prototype: GPUOutOfMemoryError;
8373 new(message: string): GPUOutOfMemoryError;
8374 isInstance: IsInstance<GPUOutOfMemoryError>;
8377 interface GPUPipelineBase {
8378 getBindGroupLayout(index: number): GPUBindGroupLayout;
8381 /** Available only in secure contexts. */
8382 interface GPUPipelineLayout extends GPUObjectBase {
8385 declare var GPUPipelineLayout: {
8386 prototype: GPUPipelineLayout;
8387 new(): GPUPipelineLayout;
8388 isInstance: IsInstance<GPUPipelineLayout>;
8391 /** Available only in secure contexts. */
8392 interface GPUQuerySet extends GPUObjectBase {
8396 declare var GPUQuerySet: {
8397 prototype: GPUQuerySet;
8399 isInstance: IsInstance<GPUQuerySet>;
8402 /** Available only in secure contexts. */
8403 interface GPUQueue extends GPUObjectBase {
8404 copyExternalImageToTexture(source: GPUImageCopyExternalImage, destination: GPUImageCopyTextureTagged, copySize: GPUExtent3D): void;
8405 onSubmittedWorkDone(): Promise<void>;
8406 submit(buffers: GPUCommandBuffer[]): void;
8407 writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: BufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void;
8408 writeTexture(destination: GPUImageCopyTexture, data: BufferSource, dataLayout: GPUImageDataLayout, size: GPUExtent3D): void;
8411 declare var GPUQueue: {
8412 prototype: GPUQueue;
8414 isInstance: IsInstance<GPUQueue>;
8417 /** Available only in secure contexts. */
8418 interface GPURenderBundle extends GPUObjectBase {
8421 declare var GPURenderBundle: {
8422 prototype: GPURenderBundle;
8423 new(): GPURenderBundle;
8424 isInstance: IsInstance<GPURenderBundle>;
8427 /** Available only in secure contexts. */
8428 interface GPURenderBundleEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase, GPURenderCommandsMixin {
8429 finish(descriptor?: GPURenderBundleDescriptor): GPURenderBundle;
8432 declare var GPURenderBundleEncoder: {
8433 prototype: GPURenderBundleEncoder;
8434 new(): GPURenderBundleEncoder;
8435 isInstance: IsInstance<GPURenderBundleEncoder>;
8438 interface GPURenderCommandsMixin {
8439 draw(vertexCount: GPUSize32, instanceCount?: GPUSize32, firstVertex?: GPUSize32, firstInstance?: GPUSize32): void;
8440 drawIndexed(indexCount: GPUSize32, instanceCount?: GPUSize32, firstIndex?: GPUSize32, baseVertex?: GPUSignedOffset32, firstInstance?: GPUSize32): void;
8441 drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
8442 drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void;
8443 setIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offset?: GPUSize64, size?: GPUSize64): void;
8444 setPipeline(pipeline: GPURenderPipeline): void;
8445 setVertexBuffer(slot: GPUIndex32, buffer: GPUBuffer, offset?: GPUSize64, size?: GPUSize64): void;
8448 /** Available only in secure contexts. */
8449 interface GPURenderPassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase, GPURenderCommandsMixin {
8451 executeBundles(bundles: GPURenderBundle[]): void;
8452 setBlendConstant(color: GPUColor): void;
8453 setScissorRect(x: GPUIntegerCoordinate, y: GPUIntegerCoordinate, width: GPUIntegerCoordinate, height: GPUIntegerCoordinate): void;
8454 setStencilReference(reference: GPUStencilValue): void;
8455 setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
8458 declare var GPURenderPassEncoder: {
8459 prototype: GPURenderPassEncoder;
8460 new(): GPURenderPassEncoder;
8461 isInstance: IsInstance<GPURenderPassEncoder>;
8464 /** Available only in secure contexts. */
8465 interface GPURenderPipeline extends GPUObjectBase, GPUPipelineBase {
8468 declare var GPURenderPipeline: {
8469 prototype: GPURenderPipeline;
8470 new(): GPURenderPipeline;
8471 isInstance: IsInstance<GPURenderPipeline>;
8474 /** Available only in secure contexts. */
8475 interface GPUSampler extends GPUObjectBase {
8478 declare var GPUSampler: {
8479 prototype: GPUSampler;
8481 isInstance: IsInstance<GPUSampler>;
8484 /** Available only in secure contexts. */
8485 interface GPUShaderModule extends GPUObjectBase {
8486 compilationInfo(): Promise<GPUCompilationInfo>;
8487 getCompilationInfo(): Promise<GPUCompilationInfo>;
8490 declare var GPUShaderModule: {
8491 prototype: GPUShaderModule;
8492 new(): GPUShaderModule;
8493 isInstance: IsInstance<GPUShaderModule>;
8496 /** Available only in secure contexts. */
8497 interface GPUShaderStage {
8498 readonly VERTEX: 0x1;
8499 readonly FRAGMENT: 0x2;
8500 readonly COMPUTE: 0x4;
8503 declare var GPUShaderStage: {
8504 prototype: GPUShaderStage;
8505 new(): GPUShaderStage;
8506 readonly VERTEX: 0x1;
8507 readonly FRAGMENT: 0x2;
8508 readonly COMPUTE: 0x4;
8509 isInstance: IsInstance<GPUShaderStage>;
8512 /** Available only in secure contexts. */
8513 interface GPUSupportedFeatures {
8514 forEach(callbackfn: (value: string, key: string, parent: GPUSupportedFeatures) => void, thisArg?: any): void;
8517 declare var GPUSupportedFeatures: {
8518 prototype: GPUSupportedFeatures;
8519 new(): GPUSupportedFeatures;
8520 isInstance: IsInstance<GPUSupportedFeatures>;
8523 /** Available only in secure contexts. */
8524 interface GPUSupportedLimits {
8525 readonly maxBindGroups: number;
8526 readonly maxBindGroupsPlusVertexBuffers: number;
8527 readonly maxBindingsPerBindGroup: number;
8528 readonly maxBufferSize: number;
8529 readonly maxColorAttachmentBytesPerSample: number;
8530 readonly maxColorAttachments: number;
8531 readonly maxComputeInvocationsPerWorkgroup: number;
8532 readonly maxComputeWorkgroupSizeX: number;
8533 readonly maxComputeWorkgroupSizeY: number;
8534 readonly maxComputeWorkgroupSizeZ: number;
8535 readonly maxComputeWorkgroupStorageSize: number;
8536 readonly maxComputeWorkgroupsPerDimension: number;
8537 readonly maxDynamicStorageBuffersPerPipelineLayout: number;
8538 readonly maxDynamicUniformBuffersPerPipelineLayout: number;
8539 readonly maxInterStageShaderComponents: number;
8540 readonly maxInterStageShaderVariables: number;
8541 readonly maxSampledTexturesPerShaderStage: number;
8542 readonly maxSamplersPerShaderStage: number;
8543 readonly maxStorageBufferBindingSize: number;
8544 readonly maxStorageBuffersPerShaderStage: number;
8545 readonly maxStorageTexturesPerShaderStage: number;
8546 readonly maxTextureArrayLayers: number;
8547 readonly maxTextureDimension1D: number;
8548 readonly maxTextureDimension2D: number;
8549 readonly maxTextureDimension3D: number;
8550 readonly maxUniformBufferBindingSize: number;
8551 readonly maxUniformBuffersPerShaderStage: number;
8552 readonly maxVertexAttributes: number;
8553 readonly maxVertexBufferArrayStride: number;
8554 readonly maxVertexBuffers: number;
8555 readonly minStorageBufferOffsetAlignment: number;
8556 readonly minUniformBufferOffsetAlignment: number;
8559 declare var GPUSupportedLimits: {
8560 prototype: GPUSupportedLimits;
8561 new(): GPUSupportedLimits;
8562 isInstance: IsInstance<GPUSupportedLimits>;
8565 /** Available only in secure contexts. */
8566 interface GPUTexture extends GPUObjectBase {
8567 readonly depthOrArrayLayers: GPUIntegerCoordinateOut;
8568 readonly dimension: GPUTextureDimension;
8569 readonly format: GPUTextureFormat;
8570 readonly height: GPUIntegerCoordinateOut;
8571 readonly mipLevelCount: GPUIntegerCoordinateOut;
8572 readonly sampleCount: GPUSize32Out;
8573 readonly usage: GPUFlagsConstant;
8574 readonly width: GPUIntegerCoordinateOut;
8575 createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
8579 declare var GPUTexture: {
8580 prototype: GPUTexture;
8582 isInstance: IsInstance<GPUTexture>;
8585 /** Available only in secure contexts. */
8586 interface GPUTextureUsage {
8587 readonly COPY_SRC: 0x01;
8588 readonly COPY_DST: 0x02;
8589 readonly TEXTURE_BINDING: 0x04;
8590 readonly STORAGE_BINDING: 0x08;
8591 readonly RENDER_ATTACHMENT: 0x10;
8594 declare var GPUTextureUsage: {
8595 prototype: GPUTextureUsage;
8596 new(): GPUTextureUsage;
8597 readonly COPY_SRC: 0x01;
8598 readonly COPY_DST: 0x02;
8599 readonly TEXTURE_BINDING: 0x04;
8600 readonly STORAGE_BINDING: 0x08;
8601 readonly RENDER_ATTACHMENT: 0x10;
8602 isInstance: IsInstance<GPUTextureUsage>;
8605 /** Available only in secure contexts. */
8606 interface GPUTextureView extends GPUObjectBase {
8609 declare var GPUTextureView: {
8610 prototype: GPUTextureView;
8611 new(): GPUTextureView;
8612 isInstance: IsInstance<GPUTextureView>;
8615 /** Available only in secure contexts. */
8616 interface GPUUncapturedErrorEvent extends Event {
8617 readonly error: GPUError;
8620 declare var GPUUncapturedErrorEvent: {
8621 prototype: GPUUncapturedErrorEvent;
8622 new(type: string, gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit): GPUUncapturedErrorEvent;
8623 isInstance: IsInstance<GPUUncapturedErrorEvent>;
8626 /** Available only in secure contexts. */
8627 interface GPUValidationError extends GPUError {
8630 declare var GPUValidationError: {
8631 prototype: GPUValidationError;
8632 new(message: string): GPUValidationError;
8633 isInstance: IsInstance<GPUValidationError>;
8636 interface GainNode extends AudioNode, AudioNodePassThrough {
8637 readonly gain: AudioParam;
8640 declare var GainNode: {
8641 prototype: GainNode;
8642 new(context: BaseAudioContext, options?: GainOptions): GainNode;
8643 isInstance: IsInstance<GainNode>;
8647 readonly axes: number[];
8648 readonly buttons: GamepadButton[];
8649 readonly connected: boolean;
8650 readonly displayId: number;
8651 readonly hand: GamepadHand;
8652 readonly hapticActuators: GamepadHapticActuator[];
8653 readonly id: string;
8654 readonly index: number;
8655 readonly lightIndicators: GamepadLightIndicator[];
8656 readonly mapping: GamepadMappingType;
8657 readonly pose: GamepadPose | null;
8658 readonly timestamp: DOMHighResTimeStamp;
8659 readonly touchEvents: GamepadTouch[];
8662 declare var Gamepad: {
8665 isInstance: IsInstance<Gamepad>;
8668 interface GamepadAxisMoveEvent extends GamepadEvent {
8669 readonly axis: number;
8670 readonly value: number;
8673 declare var GamepadAxisMoveEvent: {
8674 prototype: GamepadAxisMoveEvent;
8675 new(type: string, eventInitDict?: GamepadAxisMoveEventInit): GamepadAxisMoveEvent;
8676 isInstance: IsInstance<GamepadAxisMoveEvent>;
8679 interface GamepadButton {
8680 readonly pressed: boolean;
8681 readonly touched: boolean;
8682 readonly value: number;
8685 declare var GamepadButton: {
8686 prototype: GamepadButton;
8687 new(): GamepadButton;
8688 isInstance: IsInstance<GamepadButton>;
8691 interface GamepadButtonEvent extends GamepadEvent {
8692 readonly button: number;
8695 declare var GamepadButtonEvent: {
8696 prototype: GamepadButtonEvent;
8697 new(type: string, eventInitDict?: GamepadButtonEventInit): GamepadButtonEvent;
8698 isInstance: IsInstance<GamepadButtonEvent>;
8701 interface GamepadEvent extends Event {
8702 readonly gamepad: Gamepad | null;
8705 declare var GamepadEvent: {
8706 prototype: GamepadEvent;
8707 new(type: string, eventInitDict?: GamepadEventInit): GamepadEvent;
8708 isInstance: IsInstance<GamepadEvent>;
8711 interface GamepadHapticActuator {
8712 readonly type: GamepadHapticActuatorType;
8713 pulse(value: number, duration: number): Promise<boolean>;
8716 declare var GamepadHapticActuator: {
8717 prototype: GamepadHapticActuator;
8718 new(): GamepadHapticActuator;
8719 isInstance: IsInstance<GamepadHapticActuator>;
8722 interface GamepadLightIndicator {
8723 readonly type: GamepadLightIndicatorType;
8724 setColor(color: GamepadLightColor): Promise<boolean>;
8727 declare var GamepadLightIndicator: {
8728 prototype: GamepadLightIndicator;
8729 new(): GamepadLightIndicator;
8730 isInstance: IsInstance<GamepadLightIndicator>;
8733 interface GamepadPose {
8734 readonly angularAcceleration: Float32Array | null;
8735 readonly angularVelocity: Float32Array | null;
8736 readonly hasOrientation: boolean;
8737 readonly hasPosition: boolean;
8738 readonly linearAcceleration: Float32Array | null;
8739 readonly linearVelocity: Float32Array | null;
8740 readonly orientation: Float32Array | null;
8741 readonly position: Float32Array | null;
8744 declare var GamepadPose: {
8745 prototype: GamepadPose;
8747 isInstance: IsInstance<GamepadPose>;
8750 interface GamepadServiceTest {
8751 readonly leftHand: GamepadHand;
8752 readonly noHand: GamepadHand;
8753 readonly noMapping: GamepadMappingType;
8754 readonly rightHand: GamepadHand;
8755 readonly standardMapping: GamepadMappingType;
8756 addGamepad(id: string, mapping: GamepadMappingType, hand: GamepadHand, numButtons: number, numAxes: number, numHaptics: number, numLightIndicator: number, numTouchEvents: number): Promise<number>;
8757 newAxisMoveEvent(index: number, axis: number, value: number): Promise<number>;
8758 newButtonEvent(index: number, button: number, pressed: boolean, touched: boolean): Promise<number>;
8759 newButtonValueEvent(index: number, button: number, pressed: boolean, touched: boolean, value: number): Promise<number>;
8760 newPoseMove(index: number, orient: Float32Array | null, pos: Float32Array | null, angVelocity: Float32Array | null, angAcceleration: Float32Array | null, linVelocity: Float32Array | null, linAcceleration: Float32Array | null): Promise<number>;
8761 newTouch(index: number, aTouchArrayIndex: number, touchId: number, surfaceId: number, position: Float32Array, surfaceDimension: Float32Array | null): Promise<number>;
8762 removeGamepad(index: number): Promise<number>;
8765 declare var GamepadServiceTest: {
8766 prototype: GamepadServiceTest;
8767 new(): GamepadServiceTest;
8768 isInstance: IsInstance<GamepadServiceTest>;
8771 interface GamepadTouch {
8772 readonly position: Float32Array;
8773 readonly surfaceDimensions: Uint32Array | null;
8774 readonly surfaceId: number;
8775 readonly touchId: number;
8778 declare var GamepadTouch: {
8779 prototype: GamepadTouch;
8780 new(): GamepadTouch;
8781 isInstance: IsInstance<GamepadTouch>;
8784 interface GenericTransformStream {
8785 readonly readable: ReadableStream;
8786 readonly writable: WritableStream;
8789 interface Geolocation {
8790 clearWatch(watchId: number): void;
8791 getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback | null, options?: PositionOptions): void;
8792 watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback | null, options?: PositionOptions): number;
8795 declare var Geolocation: {
8796 prototype: Geolocation;
8798 isInstance: IsInstance<Geolocation>;
8801 /** Available only in secure contexts. */
8802 interface GeolocationCoordinates {
8803 readonly accuracy: number;
8804 readonly altitude: number | null;
8805 readonly altitudeAccuracy: number | null;
8806 readonly heading: number | null;
8807 readonly latitude: number;
8808 readonly longitude: number;
8809 readonly speed: number | null;
8812 declare var GeolocationCoordinates: {
8813 prototype: GeolocationCoordinates;
8814 new(): GeolocationCoordinates;
8815 isInstance: IsInstance<GeolocationCoordinates>;
8818 /** Available only in secure contexts. */
8819 interface GeolocationPosition {
8820 readonly coords: GeolocationCoordinates;
8821 readonly timestamp: EpochTimeStamp;
8824 declare var GeolocationPosition: {
8825 prototype: GeolocationPosition;
8826 new(): GeolocationPosition;
8827 isInstance: IsInstance<GeolocationPosition>;
8830 interface GeolocationPositionError {
8831 readonly code: number;
8832 readonly message: string;
8833 readonly PERMISSION_DENIED: 1;
8834 readonly POSITION_UNAVAILABLE: 2;
8835 readonly TIMEOUT: 3;
8838 declare var GeolocationPositionError: {
8839 prototype: GeolocationPositionError;
8840 new(): GeolocationPositionError;
8841 readonly PERMISSION_DENIED: 1;
8842 readonly POSITION_UNAVAILABLE: 2;
8843 readonly TIMEOUT: 3;
8844 isInstance: IsInstance<GeolocationPositionError>;
8847 interface GeometryUtils {
8848 convertPointFromNode(point: DOMPointInit, from: GeometryNode, options?: ConvertCoordinateOptions): DOMPoint;
8849 convertQuadFromNode(quad: DOMQuad, from: GeometryNode, options?: ConvertCoordinateOptions): DOMQuad;
8850 convertRectFromNode(rect: DOMRectReadOnly, from: GeometryNode, options?: ConvertCoordinateOptions): DOMQuad;
8851 getBoxQuads(options?: BoxQuadOptions): DOMQuad[];
8852 getBoxQuadsFromWindowOrigin(options?: BoxQuadOptions): DOMQuad[];
8855 interface GetUserMediaRequest {
8856 readonly callID: string;
8857 readonly devices: nsIMediaDevice[];
8858 readonly innerWindowID: number;
8859 readonly isHandlingUserInput: boolean;
8860 readonly isSecure: boolean;
8861 readonly mediaSource: string;
8862 readonly rawID: string;
8863 readonly type: GetUserMediaRequestType;
8864 readonly windowID: number;
8865 getAudioOutputOptions(): AudioOutputOptions;
8866 getConstraints(): MediaStreamConstraints;
8869 interface GleanBoolean extends GleanMetric {
8870 set(value: boolean): void;
8871 testGetValue(aPingName?: string): boolean | null;
8874 declare var GleanBoolean: {
8875 prototype: GleanBoolean;
8876 new(): GleanBoolean;
8877 isInstance: IsInstance<GleanBoolean>;
8880 interface GleanCategory {
8883 declare var GleanCategory: {
8884 prototype: GleanCategory;
8885 new(): GleanCategory;
8886 isInstance: IsInstance<GleanCategory>;
8889 interface GleanCounter extends GleanMetric {
8890 add(aAmount?: number): void;
8891 testGetValue(aPingName?: string): number | null;
8894 declare var GleanCounter: {
8895 prototype: GleanCounter;
8896 new(): GleanCounter;
8897 isInstance: IsInstance<GleanCounter>;
8900 interface GleanCustomDistribution extends GleanMetric {
8901 accumulateSamples(aSamples: number[]): void;
8902 accumulateSingleSample(aSample: number): void;
8903 testGetValue(aPingName?: string): GleanDistributionData | null;
8906 declare var GleanCustomDistribution: {
8907 prototype: GleanCustomDistribution;
8908 new(): GleanCustomDistribution;
8909 isInstance: IsInstance<GleanCustomDistribution>;
8912 interface GleanDatetime extends GleanMetric {
8913 set(aValue?: number): void;
8914 testGetValue(aPingName?: string): any;
8917 declare var GleanDatetime: {
8918 prototype: GleanDatetime;
8919 new(): GleanDatetime;
8920 isInstance: IsInstance<GleanDatetime>;
8923 interface GleanDenominator extends GleanMetric {
8924 add(aAmount?: number): void;
8925 testGetValue(aPingName?: string): number | null;
8928 declare var GleanDenominator: {
8929 prototype: GleanDenominator;
8930 new(): GleanDenominator;
8931 isInstance: IsInstance<GleanDenominator>;
8934 interface GleanEvent extends GleanMetric {
8935 record(aExtra?: Record<string, string | null>): void;
8936 testGetValue(aPingName?: string): GleanEventRecord[] | null;
8939 declare var GleanEvent: {
8940 prototype: GleanEvent;
8942 isInstance: IsInstance<GleanEvent>;
8945 interface GleanImpl {
8948 declare var GleanImpl: {
8949 prototype: GleanImpl;
8951 isInstance: IsInstance<GleanImpl>;
8954 interface GleanLabeled {
8957 declare var GleanLabeled: {
8958 prototype: GleanLabeled;
8959 new(): GleanLabeled;
8960 isInstance: IsInstance<GleanLabeled>;
8963 interface GleanMemoryDistribution extends GleanMetric {
8964 accumulate(aSample: number): void;
8965 testGetValue(aPingName?: string): GleanDistributionData | null;
8968 declare var GleanMemoryDistribution: {
8969 prototype: GleanMemoryDistribution;
8970 new(): GleanMemoryDistribution;
8971 isInstance: IsInstance<GleanMemoryDistribution>;
8974 interface GleanMetric {
8977 declare var GleanMetric: {
8978 prototype: GleanMetric;
8980 isInstance: IsInstance<GleanMetric>;
8983 interface GleanNumerator extends GleanMetric {
8984 addToNumerator(aAmount?: number): void;
8985 testGetValue(aPingName?: string): GleanRateData | null;
8988 declare var GleanNumerator: {
8989 prototype: GleanNumerator;
8990 new(): GleanNumerator;
8991 isInstance: IsInstance<GleanNumerator>;
8994 interface GleanObject extends GleanMetric {
8995 set(value: any): void;
8996 testGetValue(aPingName?: string): any;
8999 declare var GleanObject: {
9000 prototype: GleanObject;
9002 isInstance: IsInstance<GleanObject>;
9005 interface GleanPingsImpl {
9008 declare var GleanPingsImpl: {
9009 prototype: GleanPingsImpl;
9010 new(): GleanPingsImpl;
9011 isInstance: IsInstance<GleanPingsImpl>;
9014 interface GleanQuantity extends GleanMetric {
9015 set(aValue: number): void;
9016 testGetValue(aPingName?: string): number | null;
9019 declare var GleanQuantity: {
9020 prototype: GleanQuantity;
9021 new(): GleanQuantity;
9022 isInstance: IsInstance<GleanQuantity>;
9025 interface GleanRate extends GleanMetric {
9026 addToDenominator(aAmount?: number): void;
9027 addToNumerator(aAmount?: number): void;
9028 testGetValue(aPingName?: string): GleanRateData | null;
9031 declare var GleanRate: {
9032 prototype: GleanRate;
9034 isInstance: IsInstance<GleanRate>;
9037 interface GleanString extends GleanMetric {
9038 set(aValue: string | null): void;
9039 testGetValue(aPingName?: string): string | null;
9042 declare var GleanString: {
9043 prototype: GleanString;
9045 isInstance: IsInstance<GleanString>;
9048 interface GleanStringList extends GleanMetric {
9049 add(value: string): void;
9050 set(aValue: string[]): void;
9051 testGetValue(aPingName?: string): string[] | null;
9054 declare var GleanStringList: {
9055 prototype: GleanStringList;
9056 new(): GleanStringList;
9057 isInstance: IsInstance<GleanStringList>;
9060 interface GleanText extends GleanMetric {
9061 set(aValue: string): void;
9062 testGetValue(aPingName?: string): string | null;
9065 declare var GleanText: {
9066 prototype: GleanText;
9068 isInstance: IsInstance<GleanText>;
9071 interface GleanTimespan extends GleanMetric {
9073 setRaw(aDuration: number): void;
9076 testGetValue(aPingName?: string): number | null;
9079 declare var GleanTimespan: {
9080 prototype: GleanTimespan;
9081 new(): GleanTimespan;
9082 isInstance: IsInstance<GleanTimespan>;
9085 interface GleanTimingDistribution extends GleanMetric {
9086 cancel(aId: number): void;
9088 stopAndAccumulate(aId: number): void;
9089 testAccumulateRawMillis(aSample: number): void;
9090 testGetValue(aPingName?: string): GleanDistributionData | null;
9093 declare var GleanTimingDistribution: {
9094 prototype: GleanTimingDistribution;
9095 new(): GleanTimingDistribution;
9096 isInstance: IsInstance<GleanTimingDistribution>;
9099 interface GleanUrl extends GleanMetric {
9100 set(aValue: string): void;
9101 testGetValue(aPingName?: string): string | null;
9104 declare var GleanUrl: {
9105 prototype: GleanUrl;
9107 isInstance: IsInstance<GleanUrl>;
9110 interface GleanUuid extends GleanMetric {
9111 generateAndSet(): void;
9112 set(aValue: string): void;
9113 testGetValue(aPingName?: string): string | null;
9116 declare var GleanUuid: {
9117 prototype: GleanUuid;
9119 isInstance: IsInstance<GleanUuid>;
9122 interface GlobalCrypto {
9123 readonly crypto: Crypto;
9126 interface GlobalEventHandlersEventMap {
9128 "animationcancel": Event;
9129 "animationend": Event;
9130 "animationiteration": Event;
9131 "animationstart": Event;
9133 "beforeinput": Event;
9134 "beforetoggle": Event;
9138 "canplaythrough": Event;
9142 "contextlost": Event;
9143 "contextmenu": Event;
9144 "contextrestored": Event;
9157 "durationchange": Event;
9162 "gotpointercapture": Event;
9169 "loadeddata": Event;
9170 "loadedmetadata": Event;
9172 "lostpointercapture": Event;
9174 "mouseenter": Event;
9175 "mouseleave": Event;
9180 "mozfullscreenchange": Event;
9181 "mozfullscreenerror": Event;
9186 "pointercancel": Event;
9187 "pointerdown": Event;
9188 "pointerenter": Event;
9189 "pointerleave": Event;
9190 "pointermove": Event;
9191 "pointerout": Event;
9192 "pointerover": Event;
9195 "ratechange": Event;
9200 "securitypolicyviolation": Event;
9204 "selectionchange": Event;
9205 "selectstart": Event;
9206 "slotchange": Event;
9210 "timeupdate": Event;
9212 "transitioncancel": Event;
9213 "transitionend": Event;
9214 "transitionrun": Event;
9215 "transitionstart": Event;
9216 "volumechange": Event;
9218 "webkitanimationend": Event;
9219 "webkitanimationiteration": Event;
9220 "webkitanimationstart": Event;
9221 "webkittransitionend": Event;
9225 interface GlobalEventHandlers {
9226 onabort: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9227 onanimationcancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9228 onanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9229 onanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9230 onanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9231 onauxclick: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9232 onbeforeinput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9233 onbeforetoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9234 onblur: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9235 oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9236 oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9237 oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9238 onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9239 onclick: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9240 onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9241 oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9242 oncontextmenu: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9243 oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9244 oncopy: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9245 oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9246 oncut: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9247 ondblclick: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9248 ondrag: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9249 ondragend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9250 ondragenter: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9251 ondragexit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9252 ondragleave: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9253 ondragover: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9254 ondragstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9255 ondrop: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9256 ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9257 onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9258 onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9259 onfocus: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9260 onformdata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9261 ongotpointercapture: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9262 oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9263 oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9264 onkeydown: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9265 onkeypress: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9266 onkeyup: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9267 onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9268 onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9269 onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9270 onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9271 onlostpointercapture: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9272 onmousedown: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9273 onmouseenter: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9274 onmouseleave: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9275 onmousemove: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9276 onmouseout: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9277 onmouseover: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9278 onmouseup: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9279 onmozfullscreenchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9280 onmozfullscreenerror: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9281 onpaste: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9282 onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9283 onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9284 onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9285 onpointercancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9286 onpointerdown: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9287 onpointerenter: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9288 onpointerleave: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9289 onpointermove: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9290 onpointerout: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9291 onpointerover: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9292 onpointerup: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9293 onprogress: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9294 onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9295 onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9296 onresize: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9297 onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9298 onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9299 onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9300 onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9301 onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9302 onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9303 onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9304 onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9305 onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9306 onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9307 onsubmit: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9308 onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9309 ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9310 ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9311 ontransitioncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9312 ontransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9313 ontransitionrun: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9314 ontransitionstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9315 onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9316 onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9317 onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9318 onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9319 onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9320 onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9321 onwheel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
9322 addEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9323 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9324 removeEventListener<K extends keyof GlobalEventHandlersEventMap>(type: K, listener: (this: GlobalEventHandlers, ev: GlobalEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9325 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9328 interface GlobalPrivacyControl {
9329 readonly globalPrivacyControl: boolean;
9332 interface GlobalProcessScriptLoader {
9333 readonly initialProcessData: any;
9334 readonly sharedData: MozWritableSharedMap;
9338 readonly areas: GridArea[];
9339 readonly cols: GridDimension;
9340 readonly rows: GridDimension;
9346 isInstance: IsInstance<Grid>;
9349 interface GridArea {
9350 readonly columnEnd: number;
9351 readonly columnStart: number;
9352 readonly name: string;
9353 readonly rowEnd: number;
9354 readonly rowStart: number;
9355 readonly type: GridDeclaration;
9358 declare var GridArea: {
9359 prototype: GridArea;
9361 isInstance: IsInstance<GridArea>;
9364 interface GridDimension {
9365 readonly lines: GridLines;
9366 readonly tracks: GridTracks;
9369 declare var GridDimension: {
9370 prototype: GridDimension;
9371 new(): GridDimension;
9372 isInstance: IsInstance<GridDimension>;
9375 interface GridLine {
9376 readonly breadth: number;
9377 readonly names: string[];
9378 readonly negativeNumber: number;
9379 readonly number: number;
9380 readonly start: number;
9381 readonly type: GridDeclaration;
9384 declare var GridLine: {
9385 prototype: GridLine;
9387 isInstance: IsInstance<GridLine>;
9390 interface GridLines {
9391 readonly length: number;
9392 item(index: number): GridLine | null;
9393 [index: number]: GridLine;
9396 declare var GridLines: {
9397 prototype: GridLines;
9399 isInstance: IsInstance<GridLines>;
9402 interface GridTrack {
9403 readonly breadth: number;
9404 readonly start: number;
9405 readonly state: GridTrackState;
9406 readonly type: GridDeclaration;
9409 declare var GridTrack: {
9410 prototype: GridTrack;
9412 isInstance: IsInstance<GridTrack>;
9415 interface GridTracks {
9416 readonly length: number;
9417 item(index: number): GridTrack | null;
9418 [index: number]: GridTrack;
9421 declare var GridTracks: {
9422 prototype: GridTracks;
9424 isInstance: IsInstance<GridTracks>;
9427 interface HTMLAllCollection {
9428 readonly length: number;
9429 item(nameOrIndex?: string): HTMLCollection | Element | null;
9430 namedItem(name: string): HTMLCollection | Element | null;
9431 [index: number]: Element;
9434 declare var HTMLAllCollection: {
9435 prototype: HTMLAllCollection;
9436 new(): HTMLAllCollection;
9437 isInstance: IsInstance<HTMLAllCollection>;
9440 interface HTMLAnchorElement extends HTMLElement, HTMLHyperlinkElementUtils {
9447 referrerPolicy: string;
9449 readonly relList: DOMTokenList;
9455 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9456 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9457 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAnchorElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9458 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9461 declare var HTMLAnchorElement: {
9462 prototype: HTMLAnchorElement;
9463 new(): HTMLAnchorElement;
9464 isInstance: IsInstance<HTMLAnchorElement>;
9467 interface HTMLAreaElement extends HTMLElement, HTMLHyperlinkElementUtils {
9473 referrerPolicy: string;
9475 readonly relList: DOMTokenList;
9478 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9479 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9480 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9481 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9484 declare var HTMLAreaElement: {
9485 prototype: HTMLAreaElement;
9486 new(): HTMLAreaElement;
9487 isInstance: IsInstance<HTMLAreaElement>;
9490 interface HTMLAudioElement extends HTMLMediaElement {
9491 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9492 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9493 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLAudioElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9494 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9497 declare var HTMLAudioElement: {
9498 prototype: HTMLAudioElement;
9499 new(): HTMLAudioElement;
9500 isInstance: IsInstance<HTMLAudioElement>;
9503 interface HTMLBRElement extends HTMLElement {
9505 readonly isPaddingForEmptyEditor: boolean;
9506 readonly isPaddingForEmptyLastLine: boolean;
9507 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9508 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9509 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9510 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9513 declare var HTMLBRElement: {
9514 prototype: HTMLBRElement;
9515 new(): HTMLBRElement;
9516 isInstance: IsInstance<HTMLBRElement>;
9519 interface HTMLBaseElement extends HTMLElement {
9522 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9523 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9524 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLBaseElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9525 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9528 declare var HTMLBaseElement: {
9529 prototype: HTMLBaseElement;
9530 new(): HTMLBaseElement;
9531 isInstance: IsInstance<HTMLBaseElement>;
9534 interface HTMLBodyElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
9537 interface HTMLBodyElement extends HTMLElement, WindowEventHandlers {
9544 addEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9545 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9546 removeEventListener<K extends keyof HTMLBodyElementEventMap>(type: K, listener: (this: HTMLBodyElement, ev: HTMLBodyElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9547 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9550 declare var HTMLBodyElement: {
9551 prototype: HTMLBodyElement;
9552 new(): HTMLBodyElement;
9553 isInstance: IsInstance<HTMLBodyElement>;
9556 interface HTMLButtonElement extends HTMLElement, InvokerElement, PopoverInvokerElement {
9558 readonly form: HTMLFormElement | null;
9560 formEnctype: string;
9562 formNoValidate: boolean;
9564 readonly labels: NodeList;
9567 readonly validationMessage: string;
9568 readonly validity: ValidityState;
9570 readonly willValidate: boolean;
9571 checkValidity(): boolean;
9572 reportValidity(): boolean;
9573 setCustomValidity(error: string): void;
9574 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9575 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9576 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9577 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9580 declare var HTMLButtonElement: {
9581 prototype: HTMLButtonElement;
9582 new(): HTMLButtonElement;
9583 isInstance: IsInstance<HTMLButtonElement>;
9586 interface HTMLCanvasElement extends HTMLElement {
9589 mozPrintCallback: PrintCallback | null;
9591 captureStream(frameRate?: number): CanvasCaptureMediaStream;
9592 getContext(contextId: string, contextOptions?: any): nsISupports | null;
9593 toBlob(callback: BlobCallback, type?: string, encoderOptions?: any): void;
9594 toDataURL(type?: string, encoderOptions?: any): string;
9595 transferControlToOffscreen(): OffscreenCanvas;
9596 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9597 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9598 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9599 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9602 declare var HTMLCanvasElement: {
9603 prototype: HTMLCanvasElement;
9604 new(): HTMLCanvasElement;
9605 isInstance: IsInstance<HTMLCanvasElement>;
9608 interface HTMLCollectionBase {
9609 readonly length: number;
9610 item(index: number): Element | null;
9611 [index: number]: Element;
9614 interface HTMLCollection extends HTMLCollectionBase {
9615 namedItem(name: string): Element | null;
9618 declare var HTMLCollection: {
9619 prototype: HTMLCollection;
9620 new(): HTMLCollection;
9621 isInstance: IsInstance<HTMLCollection>;
9624 interface HTMLDListElement extends HTMLElement {
9626 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9627 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9628 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9629 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9632 declare var HTMLDListElement: {
9633 prototype: HTMLDListElement;
9634 new(): HTMLDListElement;
9635 isInstance: IsInstance<HTMLDListElement>;
9638 interface HTMLDataElement extends HTMLElement {
9640 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9641 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9642 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9643 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9646 declare var HTMLDataElement: {
9647 prototype: HTMLDataElement;
9648 new(): HTMLDataElement;
9649 isInstance: IsInstance<HTMLDataElement>;
9652 interface HTMLDataListElement extends HTMLElement {
9653 readonly options: HTMLCollection;
9654 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9655 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9656 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9657 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9660 declare var HTMLDataListElement: {
9661 prototype: HTMLDataListElement;
9662 new(): HTMLDataListElement;
9663 isInstance: IsInstance<HTMLDataListElement>;
9666 interface HTMLDetailsElement extends HTMLElement {
9668 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9669 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9670 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDetailsElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9671 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9674 declare var HTMLDetailsElement: {
9675 prototype: HTMLDetailsElement;
9676 new(): HTMLDetailsElement;
9677 isInstance: IsInstance<HTMLDetailsElement>;
9680 interface HTMLDialogElement extends HTMLElement {
9682 returnValue: string;
9683 close(returnValue?: string): void;
9686 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9687 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9688 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDialogElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9689 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9692 declare var HTMLDialogElement: {
9693 prototype: HTMLDialogElement;
9694 new(): HTMLDialogElement;
9695 isInstance: IsInstance<HTMLDialogElement>;
9698 interface HTMLDirectoryElement extends HTMLElement {
9700 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9701 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9702 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDirectoryElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9703 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9706 declare var HTMLDirectoryElement: {
9707 prototype: HTMLDirectoryElement;
9708 new(): HTMLDirectoryElement;
9709 isInstance: IsInstance<HTMLDirectoryElement>;
9712 interface HTMLDivElement extends HTMLElement {
9714 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9715 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9716 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9717 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9720 declare var HTMLDivElement: {
9721 prototype: HTMLDivElement;
9722 new(): HTMLDivElement;
9723 isInstance: IsInstance<HTMLDivElement>;
9726 interface HTMLDocument extends Document {
9727 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9728 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9729 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: HTMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9730 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9731 [name: string]: any;
9734 declare var HTMLDocument: {
9735 prototype: HTMLDocument;
9736 new(): HTMLDocument;
9737 isInstance: IsInstance<HTMLDocument>;
9740 interface HTMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, OnErrorEventHandlerForNodesEventMap, TouchEventHandlersEventMap {
9743 interface HTMLElement extends Element, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrForeignElement, OnErrorEventHandlerForNodes, TouchEventHandlers {
9745 readonly accessKeyLabel: string;
9746 autocapitalize: string;
9747 contentEditable: string;
9750 enterKeyHint: string;
9755 readonly internals: ElementInternals | null;
9756 readonly isContentEditable: boolean;
9757 readonly isFormAssociatedCustomElements: boolean;
9760 readonly offsetHeight: number;
9761 readonly offsetLeft: number;
9762 readonly offsetParent: Element | null;
9763 readonly offsetTop: number;
9764 readonly offsetWidth: number;
9766 popover: string | null;
9767 spellcheck: boolean;
9770 attachInternals(): ElementInternals;
9772 hidePopover(): void;
9773 showPopover(): void;
9774 togglePopover(force?: boolean): boolean;
9775 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9776 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9777 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9778 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9781 declare var HTMLElement: {
9782 prototype: HTMLElement;
9784 isInstance: IsInstance<HTMLElement>;
9787 interface HTMLEmbedElement extends HTMLElement, MozFrameLoaderOwner, MozObjectLoadingContent {
9794 getSVGDocument(): Document | null;
9795 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9796 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9797 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLEmbedElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9798 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9801 declare var HTMLEmbedElement: {
9802 prototype: HTMLEmbedElement;
9803 new(): HTMLEmbedElement;
9804 readonly TYPE_LOADING: 0;
9805 readonly TYPE_DOCUMENT: 1;
9806 readonly TYPE_FALLBACK: 2;
9807 isInstance: IsInstance<HTMLEmbedElement>;
9810 interface HTMLFieldSetElement extends HTMLElement {
9812 readonly elements: HTMLCollection;
9813 readonly form: HTMLFormElement | null;
9815 readonly type: string;
9816 readonly validationMessage: string;
9817 readonly validity: ValidityState;
9818 readonly willValidate: boolean;
9819 checkValidity(): boolean;
9820 reportValidity(): boolean;
9821 setCustomValidity(error: string): void;
9822 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9823 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9824 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9825 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9828 declare var HTMLFieldSetElement: {
9829 prototype: HTMLFieldSetElement;
9830 new(): HTMLFieldSetElement;
9831 isInstance: IsInstance<HTMLFieldSetElement>;
9834 interface HTMLFontElement extends HTMLElement {
9838 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9839 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9840 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFontElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9841 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9844 declare var HTMLFontElement: {
9845 prototype: HTMLFontElement;
9846 new(): HTMLFontElement;
9847 isInstance: IsInstance<HTMLFontElement>;
9850 interface HTMLFormControlsCollection extends HTMLCollectionBase {
9851 namedItem(name: string): RadioNodeList | Element | null;
9854 declare var HTMLFormControlsCollection: {
9855 prototype: HTMLFormControlsCollection;
9856 new(): HTMLFormControlsCollection;
9857 isInstance: IsInstance<HTMLFormControlsCollection>;
9860 interface HTMLFormElement extends HTMLElement {
9861 acceptCharset: string;
9863 autocomplete: string;
9864 readonly elements: HTMLFormControlsCollection;
9867 readonly length: number;
9870 noValidate: boolean;
9872 readonly relList: DOMTokenList;
9874 checkValidity(): boolean;
9875 reportValidity(): boolean;
9876 requestSubmit(submitter?: HTMLElement | null): void;
9879 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9880 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9881 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9882 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9883 [index: number]: Element;
9886 declare var HTMLFormElement: {
9887 prototype: HTMLFormElement;
9888 new(): HTMLFormElement;
9889 isInstance: IsInstance<HTMLFormElement>;
9892 interface HTMLFrameElement extends HTMLElement, MozFrameLoaderOwner {
9893 readonly contentDocument: Document | null;
9894 readonly contentWindow: WindowProxy | null;
9895 frameBorder: string;
9897 marginHeight: string;
9898 marginWidth: string;
9903 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9904 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9905 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9906 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9909 declare var HTMLFrameElement: {
9910 prototype: HTMLFrameElement;
9911 new(): HTMLFrameElement;
9912 isInstance: IsInstance<HTMLFrameElement>;
9915 interface HTMLFrameSetElementEventMap extends HTMLElementEventMap, WindowEventHandlersEventMap {
9918 interface HTMLFrameSetElement extends HTMLElement, WindowEventHandlers {
9921 addEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9922 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9923 removeEventListener<K extends keyof HTMLFrameSetElementEventMap>(type: K, listener: (this: HTMLFrameSetElement, ev: HTMLFrameSetElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9924 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9927 declare var HTMLFrameSetElement: {
9928 prototype: HTMLFrameSetElement;
9929 new(): HTMLFrameSetElement;
9930 isInstance: IsInstance<HTMLFrameSetElement>;
9933 interface HTMLHRElement extends HTMLElement {
9939 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9940 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9941 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHRElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9942 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9945 declare var HTMLHRElement: {
9946 prototype: HTMLHRElement;
9947 new(): HTMLHRElement;
9948 isInstance: IsInstance<HTMLHRElement>;
9951 interface HTMLHeadElement extends HTMLElement {
9952 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9953 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9954 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9955 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9958 declare var HTMLHeadElement: {
9959 prototype: HTMLHeadElement;
9960 new(): HTMLHeadElement;
9961 isInstance: IsInstance<HTMLHeadElement>;
9964 interface HTMLHeadingElement extends HTMLElement {
9966 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9967 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9968 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHeadingElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9969 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9972 declare var HTMLHeadingElement: {
9973 prototype: HTMLHeadingElement;
9974 new(): HTMLHeadingElement;
9975 isInstance: IsInstance<HTMLHeadingElement>;
9978 interface HTMLHtmlElement extends HTMLElement {
9980 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
9981 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
9982 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLHtmlElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
9983 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
9986 declare var HTMLHtmlElement: {
9987 prototype: HTMLHtmlElement;
9988 new(): HTMLHtmlElement;
9989 isInstance: IsInstance<HTMLHtmlElement>;
9992 interface HTMLHyperlinkElementUtils {
9998 readonly origin: string;
10007 interface HTMLIFrameElement extends HTMLElement, MozFrameLoaderOwner {
10010 allowFullscreen: boolean;
10011 readonly contentDocument: Document | null;
10012 readonly contentWindow: WindowProxy | null;
10013 readonly featurePolicy: FeaturePolicy;
10014 frameBorder: string;
10018 marginHeight: string;
10019 marginWidth: string;
10021 referrerPolicy: string;
10022 readonly sandbox: DOMTokenList;
10027 getSVGDocument(): Document | null;
10028 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10029 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10030 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLIFrameElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10031 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10034 declare var HTMLIFrameElement: {
10035 prototype: HTMLIFrameElement;
10036 new(): HTMLIFrameElement;
10037 isInstance: IsInstance<HTMLIFrameElement>;
10040 interface HTMLImageElement extends HTMLElement, MozImageLoadingContent {
10044 readonly complete: boolean;
10045 crossOrigin: string | null;
10046 readonly currentSrc: string;
10048 fetchPriority: string;
10056 readonly naturalHeight: number;
10057 readonly naturalWidth: number;
10058 referrerPolicy: string;
10065 readonly x: number;
10066 readonly y: number;
10067 decode(): Promise<void>;
10068 recognizeCurrentImageText(): Promise<ImageText[]>;
10069 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10070 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10071 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLImageElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10072 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10075 declare var HTMLImageElement: {
10076 prototype: HTMLImageElement;
10077 new(): HTMLImageElement;
10078 readonly UNKNOWN_REQUEST: -1;
10079 readonly CURRENT_REQUEST: 0;
10080 readonly PENDING_REQUEST: 1;
10081 isInstance: IsInstance<HTMLImageElement>;
10084 interface HTMLInputElement extends HTMLElement, InvokerElement, MozEditableElement, MozImageLoadingContent, PopoverInvokerElement {
10088 autocomplete: string;
10089 autofillState: string;
10092 readonly controllers: XULControllers | null;
10093 readonly dateTimeBoxElement: Element | null;
10094 defaultChecked: boolean;
10095 defaultValue: string;
10098 files: FileList | null;
10099 readonly form: HTMLFormElement | null;
10100 formAction: string;
10101 formEnctype: string;
10102 formMethod: string;
10103 formNoValidate: boolean;
10104 formTarget: string;
10105 readonly hasBeenTypePassword: boolean;
10107 indeterminate: boolean;
10108 readonly labels: NodeList | null;
10109 readonly lastInteractiveValue: string;
10110 readonly list: HTMLDataListElement | null;
10118 placeholder: string;
10119 previewValue: string;
10122 revealPassword: boolean;
10123 selectionDirection: string | null;
10124 selectionEnd: number | null;
10125 selectionStart: number | null;
10129 readonly textLength: number;
10132 readonly validationMessage: string;
10133 readonly validity: ValidityState;
10136 valueAsNumber: number;
10137 readonly webkitEntries: FileSystemEntry[];
10138 webkitdirectory: boolean;
10140 readonly willValidate: boolean;
10141 checkValidity(): boolean;
10142 closeDateTimePicker(): void;
10143 getAutocompleteInfo(): AutocompleteInfo | null;
10144 getDateTimeInputBoxValue(): DateTimeValue;
10145 getFilesAndDirectories(): Promise<(File | Directory)[]>;
10146 getMaximum(): number;
10147 getMinimum(): number;
10149 getStepBase(): number;
10150 mozGetFileNameArray(): string[];
10151 mozIsTextField(aExcludePassword: boolean): boolean;
10152 mozSetDirectory(directoryPath: string): void;
10153 mozSetDndFilesAndDirectories(list: (File | Directory)[]): void;
10154 mozSetFileArray(files: File[]): void;
10155 mozSetFileNameArray(fileNames: string[]): void;
10156 openDateTimePicker(initialValue?: DateTimeValue): void;
10157 reportValidity(): boolean;
10159 setCustomValidity(error: string): void;
10160 setFocusState(aIsFocused: boolean): void;
10161 setRangeText(replacement: string): void;
10162 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
10163 setSelectionRange(start: number, end: number, direction?: string): void;
10164 showPicker(): void;
10165 stepDown(n?: number): void;
10166 stepUp(n?: number): void;
10167 updateDateTimePicker(value?: DateTimeValue): void;
10168 updateValidityState(): void;
10169 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10170 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10171 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLInputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10172 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10175 declare var HTMLInputElement: {
10176 prototype: HTMLInputElement;
10177 new(): HTMLInputElement;
10178 readonly UNKNOWN_REQUEST: -1;
10179 readonly CURRENT_REQUEST: 0;
10180 readonly PENDING_REQUEST: 1;
10181 isInstance: IsInstance<HTMLInputElement>;
10184 interface HTMLLIElement extends HTMLElement {
10187 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10188 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10189 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLIElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10190 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10193 declare var HTMLLIElement: {
10194 prototype: HTMLLIElement;
10195 new(): HTMLLIElement;
10196 isInstance: IsInstance<HTMLLIElement>;
10199 interface HTMLLabelElement extends HTMLElement {
10200 readonly control: HTMLElement | null;
10201 readonly form: HTMLFormElement | null;
10203 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10204 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10205 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLabelElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10206 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10209 declare var HTMLLabelElement: {
10210 prototype: HTMLLabelElement;
10211 new(): HTMLLabelElement;
10212 isInstance: IsInstance<HTMLLabelElement>;
10215 interface HTMLLegendElement extends HTMLElement {
10217 readonly form: HTMLFormElement | null;
10218 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10219 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10220 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10221 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10224 declare var HTMLLegendElement: {
10225 prototype: HTMLLegendElement;
10226 new(): HTMLLegendElement;
10227 isInstance: IsInstance<HTMLLegendElement>;
10230 interface HTMLLinkElement extends HTMLElement, LinkStyle {
10232 readonly blocking: DOMTokenList;
10234 crossOrigin: string | null;
10236 fetchPriority: string;
10239 imageSizes: string;
10240 imageSrcset: string;
10243 referrerPolicy: string;
10245 readonly relList: DOMTokenList;
10247 readonly sizes: DOMTokenList;
10250 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10251 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10252 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLLinkElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10253 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10256 declare var HTMLLinkElement: {
10257 prototype: HTMLLinkElement;
10258 new(): HTMLLinkElement;
10259 isInstance: IsInstance<HTMLLinkElement>;
10262 interface HTMLMapElement extends HTMLElement {
10263 readonly areas: HTMLCollection;
10265 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10266 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10267 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMapElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10268 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10271 declare var HTMLMapElement: {
10272 prototype: HTMLMapElement;
10273 new(): HTMLMapElement;
10274 isInstance: IsInstance<HTMLMapElement>;
10277 interface HTMLMarqueeElement extends HTMLElement {
10284 scrollAmount: number;
10285 scrollDelay: number;
10286 trueSpeed: boolean;
10291 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10292 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10293 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMarqueeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10294 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10297 declare var HTMLMarqueeElement: {
10298 prototype: HTMLMarqueeElement;
10299 new(): HTMLMarqueeElement;
10300 isInstance: IsInstance<HTMLMarqueeElement>;
10303 interface HTMLMediaElementEventMap extends HTMLElementEventMap {
10304 "encrypted": Event;
10305 "waitingforkey": Event;
10308 interface HTMLMediaElement extends HTMLElement {
10309 readonly allowedToPlay: boolean;
10310 readonly audiblePlayTime: number;
10311 readonly audioTracks: AudioTrackList;
10313 readonly buffered: TimeRanges;
10314 readonly computedMuted: boolean;
10315 readonly computedVolume: number;
10317 crossOrigin: string | null;
10318 readonly currentSrc: string;
10319 currentTime: number;
10320 defaultMuted: boolean;
10321 defaultPlaybackRate: number;
10322 readonly duration: number;
10323 readonly ended: boolean;
10324 readonly error: MediaError | null;
10325 readonly inaudiblePlayTime: number;
10326 readonly invisiblePlayTime: number;
10327 readonly isEncrypted: boolean;
10328 readonly isInViewPort: boolean;
10329 readonly isSuspendedByInactiveDocOrDocShell: boolean;
10330 readonly isVideoDecodingSuspended: boolean;
10332 readonly mediaKeys: MediaKeys | null;
10333 mozAllowCasting: boolean;
10334 readonly mozAudioCaptured: boolean;
10335 readonly mozFragmentEnd: number;
10336 mozIsCasting: boolean;
10337 readonly mozMediaSourceObject: MediaSource | null;
10339 readonly mutedPlayTime: number;
10340 readonly networkState: number;
10341 onencrypted: ((this: HTMLMediaElement, ev: Event) => any) | null;
10342 onwaitingforkey: ((this: HTMLMediaElement, ev: Event) => any) | null;
10343 readonly paused: boolean;
10344 playbackRate: number;
10345 readonly played: TimeRanges;
10347 preservesPitch: boolean;
10348 readonly readyState: number;
10349 readonly seekable: TimeRanges;
10350 readonly seeking: boolean;
10351 /** Available only in secure contexts. */
10352 readonly sinkId: string;
10354 srcObject: MediaStream | null;
10355 readonly textTracks: TextTrackList | null;
10356 readonly totalAudioPlayTime: number;
10357 readonly totalVideoHDRPlayTime: number;
10358 readonly totalVideoPlayTime: number;
10359 readonly videoDecodeSuspendedTime: number;
10360 readonly videoTracks: VideoTrackList;
10361 readonly visiblePlayTime: number;
10363 addTextTrack(kind: TextTrackKind, label?: string, language?: string): TextTrack;
10364 canPlayType(type: string): string;
10365 fastSeek(time: number): void;
10366 hasSuspendTaint(): boolean;
10368 mozCaptureStream(): MediaStream;
10369 mozCaptureStreamUntilEnded(): MediaStream;
10370 mozGetMetadata(): any;
10371 mozRequestDebugInfo(): Promise<HTMLMediaElementDebugInfo>;
10372 mozRequestDebugLog(): Promise<string>;
10374 play(): Promise<void>;
10375 seekToNextFrame(): Promise<void>;
10376 setAudioSinkFailedStartup(): void;
10377 setDecodeError(error: string): void;
10378 setFormatDiagnosticsReportForMimeType(mimeType: string, error: DecoderDoctorReportType): void;
10379 setMediaKeys(mediaKeys: MediaKeys | null): Promise<void>;
10380 /** Available only in secure contexts. */
10381 setSinkId(sinkId: string): Promise<void>;
10382 setVisible(aVisible: boolean): void;
10383 readonly NETWORK_EMPTY: 0;
10384 readonly NETWORK_IDLE: 1;
10385 readonly NETWORK_LOADING: 2;
10386 readonly NETWORK_NO_SOURCE: 3;
10387 readonly HAVE_NOTHING: 0;
10388 readonly HAVE_METADATA: 1;
10389 readonly HAVE_CURRENT_DATA: 2;
10390 readonly HAVE_FUTURE_DATA: 3;
10391 readonly HAVE_ENOUGH_DATA: 4;
10392 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10393 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10394 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLMediaElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10395 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10398 declare var HTMLMediaElement: {
10399 prototype: HTMLMediaElement;
10400 new(): HTMLMediaElement;
10401 readonly NETWORK_EMPTY: 0;
10402 readonly NETWORK_IDLE: 1;
10403 readonly NETWORK_LOADING: 2;
10404 readonly NETWORK_NO_SOURCE: 3;
10405 readonly HAVE_NOTHING: 0;
10406 readonly HAVE_METADATA: 1;
10407 readonly HAVE_CURRENT_DATA: 2;
10408 readonly HAVE_FUTURE_DATA: 3;
10409 readonly HAVE_ENOUGH_DATA: 4;
10410 isInstance: IsInstance<HTMLMediaElement>;
10411 mozEnableDebugLog(): void;
10414 interface HTMLMenuElement extends HTMLElement {
10416 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10417 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10418 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMenuElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10419 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10422 declare var HTMLMenuElement: {
10423 prototype: HTMLMenuElement;
10424 new(): HTMLMenuElement;
10425 isInstance: IsInstance<HTMLMenuElement>;
10428 interface HTMLMetaElement extends HTMLElement {
10434 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10435 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10436 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMetaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10437 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10440 declare var HTMLMetaElement: {
10441 prototype: HTMLMetaElement;
10442 new(): HTMLMetaElement;
10443 isInstance: IsInstance<HTMLMetaElement>;
10446 interface HTMLMeterElement extends HTMLElement {
10448 readonly labels: NodeList;
10454 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10455 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10456 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10457 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10460 declare var HTMLMeterElement: {
10461 prototype: HTMLMeterElement;
10462 new(): HTMLMeterElement;
10463 isInstance: IsInstance<HTMLMeterElement>;
10466 interface HTMLModElement extends HTMLElement {
10469 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10470 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10471 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLModElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10472 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10475 declare var HTMLModElement: {
10476 prototype: HTMLModElement;
10477 new(): HTMLModElement;
10478 isInstance: IsInstance<HTMLModElement>;
10481 interface HTMLOListElement extends HTMLElement {
10486 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10487 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10488 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10489 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10492 declare var HTMLOListElement: {
10493 prototype: HTMLOListElement;
10494 new(): HTMLOListElement;
10495 isInstance: IsInstance<HTMLOListElement>;
10498 interface HTMLObjectElement extends HTMLElement, MozFrameLoaderOwner, MozObjectLoadingContent {
10505 readonly contentDocument: Document | null;
10506 readonly contentWindow: WindowProxy | null;
10509 readonly form: HTMLFormElement | null;
10516 readonly validationMessage: string;
10517 readonly validity: ValidityState;
10520 readonly willValidate: boolean;
10521 checkValidity(): boolean;
10522 getSVGDocument(): Document | null;
10523 reportValidity(): boolean;
10524 setCustomValidity(error: string): void;
10525 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10526 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10527 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLObjectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10528 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10531 declare var HTMLObjectElement: {
10532 prototype: HTMLObjectElement;
10533 new(): HTMLObjectElement;
10534 readonly TYPE_LOADING: 0;
10535 readonly TYPE_DOCUMENT: 1;
10536 readonly TYPE_FALLBACK: 2;
10537 isInstance: IsInstance<HTMLObjectElement>;
10540 interface HTMLOptGroupElement extends HTMLElement {
10543 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10544 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10545 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10546 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10549 declare var HTMLOptGroupElement: {
10550 prototype: HTMLOptGroupElement;
10551 new(): HTMLOptGroupElement;
10552 isInstance: IsInstance<HTMLOptGroupElement>;
10555 interface HTMLOptionElement extends HTMLElement {
10556 defaultSelected: boolean;
10558 readonly form: HTMLFormElement | null;
10559 readonly index: number;
10564 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10565 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10566 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10567 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10570 declare var HTMLOptionElement: {
10571 prototype: HTMLOptionElement;
10572 new(): HTMLOptionElement;
10573 isInstance: IsInstance<HTMLOptionElement>;
10576 interface HTMLOptionsCollection extends HTMLCollectionBase {
10578 selectedIndex: number;
10579 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
10580 remove(index: number): void;
10583 declare var HTMLOptionsCollection: {
10584 prototype: HTMLOptionsCollection;
10585 new(): HTMLOptionsCollection;
10586 isInstance: IsInstance<HTMLOptionsCollection>;
10589 interface HTMLOrForeignElement {
10590 autofocus: boolean;
10591 readonly dataset: DOMStringMap;
10594 focus(options?: FocusOptions): void;
10597 interface HTMLOutputElement extends HTMLElement {
10598 defaultValue: string;
10599 readonly form: HTMLFormElement | null;
10600 readonly htmlFor: DOMTokenList;
10601 readonly labels: NodeList;
10603 readonly type: string;
10604 readonly validationMessage: string;
10605 readonly validity: ValidityState;
10607 readonly willValidate: boolean;
10608 checkValidity(): boolean;
10609 reportValidity(): boolean;
10610 setCustomValidity(error: string): void;
10611 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10612 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10613 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10614 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10617 declare var HTMLOutputElement: {
10618 prototype: HTMLOutputElement;
10619 new(): HTMLOutputElement;
10620 isInstance: IsInstance<HTMLOutputElement>;
10623 interface HTMLParagraphElement extends HTMLElement {
10625 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10626 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10627 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParagraphElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10628 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10631 declare var HTMLParagraphElement: {
10632 prototype: HTMLParagraphElement;
10633 new(): HTMLParagraphElement;
10634 isInstance: IsInstance<HTMLParagraphElement>;
10637 interface HTMLParamElement extends HTMLElement {
10642 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10643 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10644 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLParamElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10645 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10648 declare var HTMLParamElement: {
10649 prototype: HTMLParamElement;
10650 new(): HTMLParamElement;
10651 isInstance: IsInstance<HTMLParamElement>;
10654 interface HTMLPictureElement extends HTMLElement {
10655 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10656 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10657 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPictureElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10658 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10661 declare var HTMLPictureElement: {
10662 prototype: HTMLPictureElement;
10663 new(): HTMLPictureElement;
10664 isInstance: IsInstance<HTMLPictureElement>;
10667 interface HTMLPreElement extends HTMLElement {
10669 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10670 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10671 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLPreElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10672 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10675 declare var HTMLPreElement: {
10676 prototype: HTMLPreElement;
10677 new(): HTMLPreElement;
10678 isInstance: IsInstance<HTMLPreElement>;
10681 interface HTMLProgressElement extends HTMLElement {
10682 readonly labels: NodeList;
10684 readonly position: number;
10686 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10687 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10688 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLProgressElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10689 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10692 declare var HTMLProgressElement: {
10693 prototype: HTMLProgressElement;
10694 new(): HTMLProgressElement;
10695 isInstance: IsInstance<HTMLProgressElement>;
10698 interface HTMLQuoteElement extends HTMLElement {
10700 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10701 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10702 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLQuoteElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10703 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10706 declare var HTMLQuoteElement: {
10707 prototype: HTMLQuoteElement;
10708 new(): HTMLQuoteElement;
10709 isInstance: IsInstance<HTMLQuoteElement>;
10712 interface HTMLScriptElement extends HTMLElement {
10714 readonly blocking: DOMTokenList;
10716 crossOrigin: string | null;
10719 fetchPriority: string;
10723 referrerPolicy: string;
10727 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10728 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10729 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLScriptElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10730 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10733 declare var HTMLScriptElement: {
10734 prototype: HTMLScriptElement;
10735 new(): HTMLScriptElement;
10736 isInstance: IsInstance<HTMLScriptElement>;
10737 supports(type: string): boolean;
10740 interface HTMLSelectElement extends HTMLElement {
10741 autocomplete: string;
10742 autofillState: string;
10744 readonly form: HTMLFormElement | null;
10745 readonly isCombobox: boolean;
10746 readonly labels: NodeList;
10750 openInParentProcess: boolean;
10751 readonly options: HTMLOptionsCollection;
10752 previewValue: string;
10754 selectedIndex: number;
10755 readonly selectedOptions: HTMLCollection;
10757 readonly type: string;
10758 readonly validationMessage: string;
10759 readonly validity: ValidityState;
10761 readonly willValidate: boolean;
10762 add(element: HTMLOptionElement | HTMLOptGroupElement, before?: HTMLElement | number | null): void;
10763 checkValidity(): boolean;
10764 getAutocompleteInfo(): AutocompleteInfo;
10765 item(index: number): Element | null;
10766 namedItem(name: string): HTMLOptionElement | null;
10767 remove(index: number): void;
10769 reportValidity(): boolean;
10770 setCustomValidity(error: string): void;
10771 showPicker(): void;
10772 userFinishedInteracting(changed: boolean): void;
10773 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10774 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10775 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSelectElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10776 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10777 [index: number]: Element;
10780 declare var HTMLSelectElement: {
10781 prototype: HTMLSelectElement;
10782 new(): HTMLSelectElement;
10783 isInstance: IsInstance<HTMLSelectElement>;
10786 interface HTMLSlotElement extends HTMLElement {
10788 assign(...nodes: (Element | Text)[]): void;
10789 assignedElements(options?: AssignedNodesOptions): Element[];
10790 assignedNodes(options?: AssignedNodesOptions): Node[];
10791 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10792 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10793 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSlotElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10794 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10797 declare var HTMLSlotElement: {
10798 prototype: HTMLSlotElement;
10799 new(): HTMLSlotElement;
10800 isInstance: IsInstance<HTMLSlotElement>;
10803 interface HTMLSourceElement extends HTMLElement {
10811 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10812 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10813 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSourceElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10814 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10817 declare var HTMLSourceElement: {
10818 prototype: HTMLSourceElement;
10819 new(): HTMLSourceElement;
10820 isInstance: IsInstance<HTMLSourceElement>;
10823 interface HTMLSpanElement extends HTMLElement {
10824 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10825 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10826 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLSpanElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10827 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10830 declare var HTMLSpanElement: {
10831 prototype: HTMLSpanElement;
10832 new(): HTMLSpanElement;
10833 isInstance: IsInstance<HTMLSpanElement>;
10836 interface HTMLStyleElement extends HTMLElement, LinkStyle {
10837 readonly blocking: DOMTokenList;
10841 setDevtoolsAsTriggeringPrincipal(): void;
10842 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10843 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10844 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLStyleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10845 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10848 declare var HTMLStyleElement: {
10849 prototype: HTMLStyleElement;
10850 new(): HTMLStyleElement;
10851 isInstance: IsInstance<HTMLStyleElement>;
10854 interface HTMLTableCaptionElement extends HTMLElement {
10856 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10857 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10858 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10859 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10862 declare var HTMLTableCaptionElement: {
10863 prototype: HTMLTableCaptionElement;
10864 new(): HTMLTableCaptionElement;
10865 isInstance: IsInstance<HTMLTableCaptionElement>;
10868 interface HTMLTableCellElement extends HTMLElement {
10873 readonly cellIndex: number;
10884 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10885 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10886 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableCellElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10887 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10890 declare var HTMLTableCellElement: {
10891 prototype: HTMLTableCellElement;
10892 new(): HTMLTableCellElement;
10893 isInstance: IsInstance<HTMLTableCellElement>;
10896 interface HTMLTableColElement extends HTMLElement {
10903 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10904 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10905 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableColElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10906 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10909 declare var HTMLTableColElement: {
10910 prototype: HTMLTableColElement;
10911 new(): HTMLTableColElement;
10912 isInstance: IsInstance<HTMLTableColElement>;
10915 interface HTMLTableElement extends HTMLElement {
10919 caption: HTMLTableCaptionElement | null;
10920 cellPadding: string;
10921 cellSpacing: string;
10923 readonly rows: HTMLCollection;
10926 readonly tBodies: HTMLCollection;
10927 tFoot: HTMLTableSectionElement | null;
10928 tHead: HTMLTableSectionElement | null;
10930 createCaption(): HTMLElement;
10931 createTBody(): HTMLElement;
10932 createTFoot(): HTMLElement;
10933 createTHead(): HTMLElement;
10934 deleteCaption(): void;
10935 deleteRow(index: number): void;
10936 deleteTFoot(): void;
10937 deleteTHead(): void;
10938 insertRow(index?: number): HTMLElement;
10939 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10940 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10941 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10942 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10945 declare var HTMLTableElement: {
10946 prototype: HTMLTableElement;
10947 new(): HTMLTableElement;
10948 isInstance: IsInstance<HTMLTableElement>;
10951 interface HTMLTableRowElement extends HTMLElement {
10954 readonly cells: HTMLCollection;
10957 readonly rowIndex: number;
10958 readonly sectionRowIndex: number;
10960 deleteCell(index: number): void;
10961 insertCell(index?: number): HTMLElement;
10962 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10963 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10964 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableRowElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10965 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10968 declare var HTMLTableRowElement: {
10969 prototype: HTMLTableRowElement;
10970 new(): HTMLTableRowElement;
10971 isInstance: IsInstance<HTMLTableRowElement>;
10974 interface HTMLTableSectionElement extends HTMLElement {
10978 readonly rows: HTMLCollection;
10980 deleteRow(index: number): void;
10981 insertRow(index?: number): HTMLElement;
10982 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
10983 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
10984 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTableSectionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
10985 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
10988 declare var HTMLTableSectionElement: {
10989 prototype: HTMLTableSectionElement;
10990 new(): HTMLTableSectionElement;
10991 isInstance: IsInstance<HTMLTableSectionElement>;
10994 interface HTMLTemplateElement extends HTMLElement {
10995 readonly content: DocumentFragment;
10996 shadowRootClonable: boolean;
10997 shadowRootDelegatesFocus: boolean;
10998 shadowRootMode: string;
10999 shadowRootSerializable: boolean;
11000 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11001 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11002 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTemplateElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11003 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11006 declare var HTMLTemplateElement: {
11007 prototype: HTMLTemplateElement;
11008 new(): HTMLTemplateElement;
11009 isInstance: IsInstance<HTMLTemplateElement>;
11012 interface HTMLTextAreaElement extends HTMLElement, MozEditableElement {
11013 autocomplete: string;
11015 readonly controllers: XULControllers;
11016 defaultValue: string;
11019 readonly form: HTMLFormElement | null;
11020 readonly labels: NodeList;
11024 placeholder: string;
11025 previewValue: string;
11029 selectionDirection: string | null;
11030 selectionEnd: number | null;
11031 selectionStart: number | null;
11032 readonly textLength: number;
11033 readonly type: string;
11034 readonly validationMessage: string;
11035 readonly validity: ValidityState;
11037 readonly willValidate: boolean;
11039 checkValidity(): boolean;
11040 reportValidity(): boolean;
11042 setCustomValidity(error: string): void;
11043 setRangeText(replacement: string): void;
11044 setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void;
11045 setSelectionRange(start: number, end: number, direction?: string): void;
11046 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11047 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11048 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11049 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11052 declare var HTMLTextAreaElement: {
11053 prototype: HTMLTextAreaElement;
11054 new(): HTMLTextAreaElement;
11055 isInstance: IsInstance<HTMLTextAreaElement>;
11058 interface HTMLTimeElement extends HTMLElement {
11060 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11061 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11062 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTimeElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11063 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11066 declare var HTMLTimeElement: {
11067 prototype: HTMLTimeElement;
11068 new(): HTMLTimeElement;
11069 isInstance: IsInstance<HTMLTimeElement>;
11072 interface HTMLTitleElement extends HTMLElement {
11074 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11075 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11076 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTitleElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11077 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11080 declare var HTMLTitleElement: {
11081 prototype: HTMLTitleElement;
11082 new(): HTMLTitleElement;
11083 isInstance: IsInstance<HTMLTitleElement>;
11086 interface HTMLTrackElement extends HTMLElement {
11090 readonly readyState: number;
11093 readonly track: TextTrack | null;
11095 readonly LOADING: 1;
11096 readonly LOADED: 2;
11098 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11099 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11100 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLTrackElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11101 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11104 declare var HTMLTrackElement: {
11105 prototype: HTMLTrackElement;
11106 new(): HTMLTrackElement;
11108 readonly LOADING: 1;
11109 readonly LOADED: 2;
11111 isInstance: IsInstance<HTMLTrackElement>;
11114 interface HTMLUListElement extends HTMLElement {
11117 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11118 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11119 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11120 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11123 declare var HTMLUListElement: {
11124 prototype: HTMLUListElement;
11125 new(): HTMLUListElement;
11126 isInstance: IsInstance<HTMLUListElement>;
11129 interface HTMLUnknownElement extends HTMLElement {
11130 addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11131 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11132 removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLUnknownElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11133 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11136 declare var HTMLUnknownElement: {
11137 prototype: HTMLUnknownElement;
11138 new(): HTMLUnknownElement;
11139 isInstance: IsInstance<HTMLUnknownElement>;
11142 interface HTMLVideoElement extends HTMLMediaElement {
11143 disablePictureInPicture: boolean;
11145 readonly isCloningElementVisually: boolean;
11146 readonly mozDecodedFrames: number;
11147 readonly mozFrameDelay: number;
11148 readonly mozHasAudio: boolean;
11149 readonly mozPaintedFrames: number;
11150 readonly mozParsedFrames: number;
11151 readonly mozPresentedFrames: number;
11153 readonly videoHeight: number;
11154 readonly videoWidth: number;
11156 cloneElementVisually(target: HTMLVideoElement): Promise<void>;
11157 getVideoPlaybackQuality(): VideoPlaybackQuality;
11158 stopCloningElementVisually(): void;
11159 addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11160 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11161 removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (this: HTMLVideoElement, ev: HTMLMediaElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11162 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11165 declare var HTMLVideoElement: {
11166 prototype: HTMLVideoElement;
11167 new(): HTMLVideoElement;
11168 isInstance: IsInstance<HTMLVideoElement>;
11171 interface HashChangeEvent extends Event {
11172 readonly newURL: string;
11173 readonly oldURL: string;
11176 declare var HashChangeEvent: {
11177 prototype: HashChangeEvent;
11178 new(type: string, eventInitDict?: HashChangeEventInit): HashChangeEvent;
11179 isInstance: IsInstance<HashChangeEvent>;
11182 interface Headers {
11183 guard: HeadersGuardEnum;
11184 append(name: string, value: string): void;
11185 delete(name: string): void;
11186 get(name: string): string | null;
11187 getSetCookie(): string[];
11188 has(name: string): boolean;
11189 set(name: string, value: string): void;
11190 forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
11193 declare var Headers: {
11194 prototype: Headers;
11195 new(init?: HeadersInit): Headers;
11196 isInstance: IsInstance<Headers>;
11199 interface HeapSnapshot {
11200 readonly creationTime: number | null;
11201 computeDominatorTree(): DominatorTree;
11202 computeShortestPaths(start: NodeId, targets: NodeId[], maxNumPaths: number): any;
11203 describeNode(breakdown: any, node: NodeId): any;
11204 takeCensus(options: any): any;
11207 declare var HeapSnapshot: {
11208 prototype: HeapSnapshot;
11209 new(): HeapSnapshot;
11210 isInstance: IsInstance<HeapSnapshot>;
11213 interface Highlight {
11215 type: HighlightType;
11216 forEach(callbackfn: (value: AbstractRange, key: AbstractRange, parent: Highlight) => void, thisArg?: any): void;
11219 declare var Highlight: {
11220 prototype: Highlight;
11221 new(...initialRanges: AbstractRange[]): Highlight;
11222 isInstance: IsInstance<Highlight>;
11225 interface HighlightRegistry {
11226 forEach(callbackfn: (value: Highlight, key: string, parent: HighlightRegistry) => void, thisArg?: any): void;
11229 declare var HighlightRegistry: {
11230 prototype: HighlightRegistry;
11231 new(): HighlightRegistry;
11232 isInstance: IsInstance<HighlightRegistry>;
11235 interface History {
11236 readonly length: number;
11237 scrollRestoration: ScrollRestoration;
11238 readonly state: any;
11241 go(delta?: number): void;
11242 pushState(data: any, title: string, url?: string | null): void;
11243 replaceState(data: any, title: string, url?: string | null): void;
11246 declare var History: {
11247 prototype: History;
11249 isInstance: IsInstance<History>;
11252 interface IDBCursor {
11253 readonly direction: IDBCursorDirection;
11255 readonly primaryKey: any;
11256 readonly request: IDBRequest;
11257 readonly source: IDBObjectStore | IDBIndex;
11258 advance(count: number): void;
11259 continue(key?: any): void;
11260 continuePrimaryKey(key: any, primaryKey: any): void;
11261 delete(): IDBRequest;
11262 update(value: any): IDBRequest;
11265 declare var IDBCursor: {
11266 prototype: IDBCursor;
11268 isInstance: IsInstance<IDBCursor>;
11271 interface IDBCursorWithValue extends IDBCursor {
11272 readonly value: any;
11275 declare var IDBCursorWithValue: {
11276 prototype: IDBCursorWithValue;
11277 new(): IDBCursorWithValue;
11278 isInstance: IsInstance<IDBCursorWithValue>;
11281 interface IDBDatabaseEventMap {
11285 "versionchange": Event;
11288 interface IDBDatabase extends EventTarget {
11289 readonly name: string;
11290 readonly objectStoreNames: DOMStringList;
11291 onabort: ((this: IDBDatabase, ev: Event) => any) | null;
11292 onclose: ((this: IDBDatabase, ev: Event) => any) | null;
11293 onerror: ((this: IDBDatabase, ev: Event) => any) | null;
11294 onversionchange: ((this: IDBDatabase, ev: Event) => any) | null;
11295 readonly version: number;
11297 createObjectStore(name: string, options?: IDBObjectStoreParameters): IDBObjectStore;
11298 deleteObjectStore(name: string): void;
11299 transaction(storeNames: string | string[], mode?: IDBTransactionMode, options?: IDBTransactionOptions): IDBTransaction;
11300 addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11301 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11302 removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11303 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11306 declare var IDBDatabase: {
11307 prototype: IDBDatabase;
11308 new(): IDBDatabase;
11309 isInstance: IsInstance<IDBDatabase>;
11312 interface IDBFactory {
11313 cmp(first: any, second: any): number;
11314 databases(): Promise<IDBDatabaseInfo[]>;
11315 deleteDatabase(name: string): IDBOpenDBRequest;
11316 deleteForPrincipal(principal: Principal, name: string, options?: IDBOpenDBOptions): IDBOpenDBRequest;
11317 open(name: string, version?: number): IDBOpenDBRequest;
11318 openForPrincipal(principal: Principal, name: string, version: number): IDBOpenDBRequest;
11319 openForPrincipal(principal: Principal, name: string, options?: IDBOpenDBOptions): IDBOpenDBRequest;
11322 declare var IDBFactory: {
11323 prototype: IDBFactory;
11325 isInstance: IsInstance<IDBFactory>;
11328 interface IDBIndex {
11329 readonly isAutoLocale: boolean;
11330 readonly keyPath: any;
11331 readonly locale: string | null;
11332 readonly multiEntry: boolean;
11334 readonly objectStore: IDBObjectStore;
11335 readonly unique: boolean;
11336 count(query?: any): IDBRequest;
11337 get(query: any): IDBRequest;
11338 getAll(query?: any, count?: number): IDBRequest;
11339 getAllKeys(query?: any, count?: number): IDBRequest;
11340 getKey(query: any): IDBRequest;
11341 openCursor(query?: any, direction?: IDBCursorDirection): IDBRequest;
11342 openKeyCursor(query?: any, direction?: IDBCursorDirection): IDBRequest;
11345 declare var IDBIndex: {
11346 prototype: IDBIndex;
11348 isInstance: IsInstance<IDBIndex>;
11351 interface IDBKeyRange {
11352 readonly lower: any;
11353 readonly lowerOpen: boolean;
11354 readonly upper: any;
11355 readonly upperOpen: boolean;
11356 includes(key: any): boolean;
11359 declare var IDBKeyRange: {
11360 prototype: IDBKeyRange;
11361 new(): IDBKeyRange;
11362 isInstance: IsInstance<IDBKeyRange>;
11363 bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
11364 lowerBound(lower: any, open?: boolean): IDBKeyRange;
11365 only(value: any): IDBKeyRange;
11366 upperBound(upper: any, open?: boolean): IDBKeyRange;
11369 interface IDBObjectStore {
11370 readonly autoIncrement: boolean;
11371 readonly indexNames: DOMStringList;
11372 readonly keyPath: any;
11374 readonly transaction: IDBTransaction;
11375 add(value: any, key?: any): IDBRequest;
11376 clear(): IDBRequest;
11377 count(key?: any): IDBRequest;
11378 createIndex(name: string, keyPath: string | string[], optionalParameters?: IDBIndexParameters): IDBIndex;
11379 delete(key: any): IDBRequest;
11380 deleteIndex(indexName: string): void;
11381 get(key: any): IDBRequest;
11382 getAll(query?: any, count?: number): IDBRequest;
11383 getAllKeys(query?: any, count?: number): IDBRequest;
11384 getKey(key: any): IDBRequest;
11385 index(name: string): IDBIndex;
11386 openCursor(range?: any, direction?: IDBCursorDirection): IDBRequest;
11387 openKeyCursor(query?: any, direction?: IDBCursorDirection): IDBRequest;
11388 put(value: any, key?: any): IDBRequest;
11391 declare var IDBObjectStore: {
11392 prototype: IDBObjectStore;
11393 new(): IDBObjectStore;
11394 isInstance: IsInstance<IDBObjectStore>;
11397 interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
11399 "upgradeneeded": Event;
11402 interface IDBOpenDBRequest extends IDBRequest {
11403 onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
11404 onupgradeneeded: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
11405 addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11406 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11407 removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11408 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11411 declare var IDBOpenDBRequest: {
11412 prototype: IDBOpenDBRequest;
11413 new(): IDBOpenDBRequest;
11414 isInstance: IsInstance<IDBOpenDBRequest>;
11417 interface IDBRequestEventMap {
11422 interface IDBRequest extends EventTarget {
11423 readonly error: DOMException | null;
11424 onerror: ((this: IDBRequest, ev: Event) => any) | null;
11425 onsuccess: ((this: IDBRequest, ev: Event) => any) | null;
11426 readonly readyState: IDBRequestReadyState;
11427 readonly result: any;
11428 readonly source: IDBObjectStore | IDBIndex | IDBCursor | null;
11429 readonly transaction: IDBTransaction | null;
11430 addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11431 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11432 removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11433 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11436 declare var IDBRequest: {
11437 prototype: IDBRequest;
11439 isInstance: IsInstance<IDBRequest>;
11442 interface IDBTransactionEventMap {
11448 interface IDBTransaction extends EventTarget {
11449 readonly db: IDBDatabase;
11450 readonly durability: IDBTransactionDurability;
11451 readonly error: DOMException | null;
11452 readonly mode: IDBTransactionMode;
11453 readonly objectStoreNames: DOMStringList;
11454 onabort: ((this: IDBTransaction, ev: Event) => any) | null;
11455 oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
11456 onerror: ((this: IDBTransaction, ev: Event) => any) | null;
11459 objectStore(name: string): IDBObjectStore;
11460 addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11461 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11462 removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11463 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11466 declare var IDBTransaction: {
11467 prototype: IDBTransaction;
11468 new(): IDBTransaction;
11469 isInstance: IsInstance<IDBTransaction>;
11472 interface IDBVersionChangeEvent extends Event {
11473 readonly newVersion: number | null;
11474 readonly oldVersion: number;
11477 declare var IDBVersionChangeEvent: {
11478 prototype: IDBVersionChangeEvent;
11479 new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
11480 isInstance: IsInstance<IDBVersionChangeEvent>;
11483 interface IIRFilterNode extends AudioNode, AudioNodePassThrough {
11484 getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
11487 declare var IIRFilterNode: {
11488 prototype: IIRFilterNode;
11489 new(context: BaseAudioContext, options: IIRFilterOptions): IIRFilterNode;
11490 isInstance: IsInstance<IIRFilterNode>;
11493 /** Available only in secure contexts. */
11494 interface IdentityCredential extends Credential {
11495 readonly origin: string;
11496 readonly token: string | null;
11499 declare var IdentityCredential: {
11500 prototype: IdentityCredential;
11501 new(init: IdentityCredentialInit): IdentityCredential;
11502 isInstance: IsInstance<IdentityCredential>;
11505 interface IdleDeadline {
11506 readonly didTimeout: boolean;
11507 timeRemaining(): DOMHighResTimeStamp;
11510 declare var IdleDeadline: {
11511 prototype: IdleDeadline;
11512 new(): IdleDeadline;
11513 isInstance: IsInstance<IdleDeadline>;
11516 interface ImageBitmap {
11517 readonly height: number;
11518 readonly width: number;
11522 declare var ImageBitmap: {
11523 prototype: ImageBitmap;
11524 new(): ImageBitmap;
11525 isInstance: IsInstance<ImageBitmap>;
11528 interface ImageBitmapRenderingContext {
11529 readonly canvas: CanvasSource | null;
11530 transferFromImageBitmap(bitmap: ImageBitmap | null): void;
11531 transferImageBitmap(bitmap: ImageBitmap): void;
11534 declare var ImageBitmapRenderingContext: {
11535 prototype: ImageBitmapRenderingContext;
11536 new(): ImageBitmapRenderingContext;
11537 isInstance: IsInstance<ImageBitmapRenderingContext>;
11540 interface ImageCaptureEventMap {
11545 interface ImageCapture extends EventTarget {
11546 onerror: ((this: ImageCapture, ev: Event) => any) | null;
11547 onphoto: ((this: ImageCapture, ev: Event) => any) | null;
11548 readonly videoStreamTrack: MediaStreamTrack;
11550 addEventListener<K extends keyof ImageCaptureEventMap>(type: K, listener: (this: ImageCapture, ev: ImageCaptureEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11551 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11552 removeEventListener<K extends keyof ImageCaptureEventMap>(type: K, listener: (this: ImageCapture, ev: ImageCaptureEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11553 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11556 declare var ImageCapture: {
11557 prototype: ImageCapture;
11558 new(track: MediaStreamTrack): ImageCapture;
11559 isInstance: IsInstance<ImageCapture>;
11562 interface ImageCaptureError {
11563 readonly code: number;
11564 readonly message: string;
11565 readonly FRAME_GRAB_ERROR: 1;
11566 readonly SETTINGS_ERROR: 2;
11567 readonly PHOTO_ERROR: 3;
11568 readonly ERROR_UNKNOWN: 4;
11571 interface ImageCaptureErrorEvent extends Event {
11572 readonly imageCaptureError: ImageCaptureError | null;
11575 declare var ImageCaptureErrorEvent: {
11576 prototype: ImageCaptureErrorEvent;
11577 new(type: string, imageCaptureErrorInitDict?: ImageCaptureErrorEventInit): ImageCaptureErrorEvent;
11578 isInstance: IsInstance<ImageCaptureErrorEvent>;
11581 interface ImageData {
11582 readonly data: Uint8ClampedArray;
11583 readonly height: number;
11584 readonly width: number;
11587 declare var ImageData: {
11588 prototype: ImageData;
11589 new(sw: number, sh: number): ImageData;
11590 new(data: Uint8ClampedArray, sw: number, sh?: number): ImageData;
11591 isInstance: IsInstance<ImageData>;
11594 interface ImageDocument extends HTMLDocument {
11595 readonly imageIsOverflowing: boolean;
11596 readonly imageIsResized: boolean;
11597 restoreImage(): void;
11598 shrinkToFit(): void;
11599 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: ImageDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
11600 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
11601 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: ImageDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
11602 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
11605 declare var ImageDocument: {
11606 prototype: ImageDocument;
11607 new(): ImageDocument;
11608 isInstance: IsInstance<ImageDocument>;
11611 interface InputEvent extends UIEvent {
11612 readonly data: string | null;
11613 readonly dataTransfer: DataTransfer | null;
11614 readonly inputType: string;
11615 readonly isComposing: boolean;
11616 getTargetRanges(): StaticRange[];
11619 declare var InputEvent: {
11620 prototype: InputEvent;
11621 new(type: string, eventInitDict?: InputEventInit): InputEvent;
11622 isInstance: IsInstance<InputEvent>;
11625 interface InputStream {
11628 interface InspectorCSSParser {
11629 readonly columnNumber: number;
11630 readonly lineNumber: number;
11631 nextToken(): InspectorCSSToken | null;
11634 declare var InspectorCSSParser: {
11635 prototype: InspectorCSSParser;
11636 new(text: string): InspectorCSSParser;
11637 isInstance: IsInstance<InspectorCSSParser>;
11640 interface InspectorFontFace {
11641 readonly CSSFamilyName: string;
11642 readonly CSSGeneric: string;
11643 readonly URI: string;
11644 readonly format: string;
11645 readonly fromFontGroup: boolean;
11646 readonly fromLanguagePrefs: boolean;
11647 readonly fromSystemFallback: boolean;
11648 readonly localName: string;
11649 readonly metadata: string;
11650 readonly name: string;
11651 readonly ranges: Range[];
11652 readonly rule: CSSFontFaceRule | null;
11653 readonly srcIndex: number;
11654 getFeatures(): InspectorFontFeature[];
11655 getVariationAxes(): InspectorVariationAxis[];
11656 getVariationInstances(): InspectorVariationInstance[];
11659 declare var InspectorFontFace: {
11660 prototype: InspectorFontFace;
11661 new(): InspectorFontFace;
11662 isInstance: IsInstance<InspectorFontFace>;
11665 interface InstallTriggerImpl {
11666 enabled(): boolean;
11667 install(installs: Record<string, string | InstallTriggerData>, callback?: InstallTriggerCallback): boolean;
11668 installChrome(type: number, url: string, skin: string): boolean;
11669 startSoftwareUpdate(url: string, flags?: number): boolean;
11670 updateEnabled(): boolean;
11672 readonly LOCALE: 2;
11673 readonly CONTENT: 4;
11674 readonly PACKAGE: 7;
11677 declare var InstallTriggerImpl: {
11678 prototype: InstallTriggerImpl;
11679 new(): InstallTriggerImpl;
11681 readonly LOCALE: 2;
11682 readonly CONTENT: 4;
11683 readonly PACKAGE: 7;
11684 isInstance: IsInstance<InstallTriggerImpl>;
11687 interface IntersectionObserver {
11688 readonly root: Node | null;
11689 readonly rootMargin: string;
11690 readonly thresholds: number[];
11691 disconnect(): void;
11692 observe(target: Element): void;
11693 takeRecords(): IntersectionObserverEntry[];
11694 unobserve(target: Element): void;
11697 declare var IntersectionObserver: {
11698 prototype: IntersectionObserver;
11699 new(intersectionCallback: IntersectionCallback, options?: IntersectionObserverInit): IntersectionObserver;
11700 isInstance: IsInstance<IntersectionObserver>;
11703 interface IntersectionObserverEntry {
11704 readonly boundingClientRect: DOMRectReadOnly;
11705 readonly intersectionRatio: number;
11706 readonly intersectionRect: DOMRectReadOnly;
11707 readonly isIntersecting: boolean;
11708 readonly rootBounds: DOMRectReadOnly | null;
11709 readonly target: Element;
11710 readonly time: DOMHighResTimeStamp;
11713 declare var IntersectionObserverEntry: {
11714 prototype: IntersectionObserverEntry;
11715 new(): IntersectionObserverEntry;
11716 isInstance: IsInstance<IntersectionObserverEntry>;
11719 interface IntlUtils {
11720 getDisplayNames(locales: string[], options?: DisplayNameOptions): DisplayNameResult;
11721 isAppLocaleRTL(): boolean;
11724 interface InvokeEvent extends Event {
11725 readonly action: string;
11726 readonly invoker: Element | null;
11729 declare var InvokeEvent: {
11730 prototype: InvokeEvent;
11731 new(type: string, eventInitDict?: InvokeEventInit): InvokeEvent;
11732 isInstance: IsInstance<InvokeEvent>;
11735 interface InvokerElement {
11736 invokeAction: string;
11737 invokeTargetElement: Element | null;
11741 interface JSActor {
11742 readonly name: string;
11743 sendAsyncMessage(messageName: string, obj?: any, transferables?: any): void;
11744 sendQuery(messageName: string, obj?: any): Promise<any>;
11747 interface JSProcessActorChild extends JSActor {
11748 readonly manager: nsIDOMProcessChild;
11751 declare var JSProcessActorChild: {
11752 prototype: JSProcessActorChild;
11753 new(): JSProcessActorChild;
11754 isInstance: IsInstance<JSProcessActorChild>;
11757 interface JSProcessActorParent extends JSActor {
11758 readonly manager: nsIDOMProcessParent;
11761 declare var JSProcessActorParent: {
11762 prototype: JSProcessActorParent;
11763 new(): JSProcessActorParent;
11764 isInstance: IsInstance<JSProcessActorParent>;
11767 interface JSString {
11770 interface JSWindowActorChild extends JSActor {
11771 readonly browsingContext: BrowsingContext | null;
11772 readonly contentWindow: WindowProxy | null;
11773 readonly docShell: nsIDocShell | null;
11774 readonly document: Document | null;
11775 readonly manager: WindowGlobalChild | null;
11776 readonly windowContext: WindowContext | null;
11779 declare var JSWindowActorChild: {
11780 prototype: JSWindowActorChild;
11781 new(): JSWindowActorChild;
11782 isInstance: IsInstance<JSWindowActorChild>;
11785 interface JSWindowActorParent extends JSActor {
11786 readonly browsingContext: CanonicalBrowsingContext | null;
11787 readonly manager: WindowGlobalParent | null;
11788 readonly windowContext: WindowContext | null;
11791 declare var JSWindowActorParent: {
11792 prototype: JSWindowActorParent;
11793 new(): JSWindowActorParent;
11794 isInstance: IsInstance<JSWindowActorParent>;
11797 interface KeyEvent extends KeyEventMixin {
11800 declare var KeyEvent: {
11801 prototype: KeyEvent;
11803 readonly DOM_VK_CANCEL: 0x03;
11804 readonly DOM_VK_HELP: 0x06;
11805 readonly DOM_VK_BACK_SPACE: 0x08;
11806 readonly DOM_VK_TAB: 0x09;
11807 readonly DOM_VK_CLEAR: 0x0C;
11808 readonly DOM_VK_RETURN: 0x0D;
11809 readonly DOM_VK_SHIFT: 0x10;
11810 readonly DOM_VK_CONTROL: 0x11;
11811 readonly DOM_VK_ALT: 0x12;
11812 readonly DOM_VK_PAUSE: 0x13;
11813 readonly DOM_VK_CAPS_LOCK: 0x14;
11814 readonly DOM_VK_KANA: 0x15;
11815 readonly DOM_VK_HANGUL: 0x15;
11816 readonly DOM_VK_EISU: 0x16;
11817 readonly DOM_VK_JUNJA: 0x17;
11818 readonly DOM_VK_FINAL: 0x18;
11819 readonly DOM_VK_HANJA: 0x19;
11820 readonly DOM_VK_KANJI: 0x19;
11821 readonly DOM_VK_ESCAPE: 0x1B;
11822 readonly DOM_VK_CONVERT: 0x1C;
11823 readonly DOM_VK_NONCONVERT: 0x1D;
11824 readonly DOM_VK_ACCEPT: 0x1E;
11825 readonly DOM_VK_MODECHANGE: 0x1F;
11826 readonly DOM_VK_SPACE: 0x20;
11827 readonly DOM_VK_PAGE_UP: 0x21;
11828 readonly DOM_VK_PAGE_DOWN: 0x22;
11829 readonly DOM_VK_END: 0x23;
11830 readonly DOM_VK_HOME: 0x24;
11831 readonly DOM_VK_LEFT: 0x25;
11832 readonly DOM_VK_UP: 0x26;
11833 readonly DOM_VK_RIGHT: 0x27;
11834 readonly DOM_VK_DOWN: 0x28;
11835 readonly DOM_VK_SELECT: 0x29;
11836 readonly DOM_VK_PRINT: 0x2A;
11837 readonly DOM_VK_EXECUTE: 0x2B;
11838 readonly DOM_VK_PRINTSCREEN: 0x2C;
11839 readonly DOM_VK_INSERT: 0x2D;
11840 readonly DOM_VK_DELETE: 0x2E;
11841 readonly DOM_VK_0: 0x30;
11842 readonly DOM_VK_1: 0x31;
11843 readonly DOM_VK_2: 0x32;
11844 readonly DOM_VK_3: 0x33;
11845 readonly DOM_VK_4: 0x34;
11846 readonly DOM_VK_5: 0x35;
11847 readonly DOM_VK_6: 0x36;
11848 readonly DOM_VK_7: 0x37;
11849 readonly DOM_VK_8: 0x38;
11850 readonly DOM_VK_9: 0x39;
11851 readonly DOM_VK_COLON: 0x3A;
11852 readonly DOM_VK_SEMICOLON: 0x3B;
11853 readonly DOM_VK_LESS_THAN: 0x3C;
11854 readonly DOM_VK_EQUALS: 0x3D;
11855 readonly DOM_VK_GREATER_THAN: 0x3E;
11856 readonly DOM_VK_QUESTION_MARK: 0x3F;
11857 readonly DOM_VK_AT: 0x40;
11858 readonly DOM_VK_A: 0x41;
11859 readonly DOM_VK_B: 0x42;
11860 readonly DOM_VK_C: 0x43;
11861 readonly DOM_VK_D: 0x44;
11862 readonly DOM_VK_E: 0x45;
11863 readonly DOM_VK_F: 0x46;
11864 readonly DOM_VK_G: 0x47;
11865 readonly DOM_VK_H: 0x48;
11866 readonly DOM_VK_I: 0x49;
11867 readonly DOM_VK_J: 0x4A;
11868 readonly DOM_VK_K: 0x4B;
11869 readonly DOM_VK_L: 0x4C;
11870 readonly DOM_VK_M: 0x4D;
11871 readonly DOM_VK_N: 0x4E;
11872 readonly DOM_VK_O: 0x4F;
11873 readonly DOM_VK_P: 0x50;
11874 readonly DOM_VK_Q: 0x51;
11875 readonly DOM_VK_R: 0x52;
11876 readonly DOM_VK_S: 0x53;
11877 readonly DOM_VK_T: 0x54;
11878 readonly DOM_VK_U: 0x55;
11879 readonly DOM_VK_V: 0x56;
11880 readonly DOM_VK_W: 0x57;
11881 readonly DOM_VK_X: 0x58;
11882 readonly DOM_VK_Y: 0x59;
11883 readonly DOM_VK_Z: 0x5A;
11884 readonly DOM_VK_WIN: 0x5B;
11885 readonly DOM_VK_CONTEXT_MENU: 0x5D;
11886 readonly DOM_VK_SLEEP: 0x5F;
11887 readonly DOM_VK_NUMPAD0: 0x60;
11888 readonly DOM_VK_NUMPAD1: 0x61;
11889 readonly DOM_VK_NUMPAD2: 0x62;
11890 readonly DOM_VK_NUMPAD3: 0x63;
11891 readonly DOM_VK_NUMPAD4: 0x64;
11892 readonly DOM_VK_NUMPAD5: 0x65;
11893 readonly DOM_VK_NUMPAD6: 0x66;
11894 readonly DOM_VK_NUMPAD7: 0x67;
11895 readonly DOM_VK_NUMPAD8: 0x68;
11896 readonly DOM_VK_NUMPAD9: 0x69;
11897 readonly DOM_VK_MULTIPLY: 0x6A;
11898 readonly DOM_VK_ADD: 0x6B;
11899 readonly DOM_VK_SEPARATOR: 0x6C;
11900 readonly DOM_VK_SUBTRACT: 0x6D;
11901 readonly DOM_VK_DECIMAL: 0x6E;
11902 readonly DOM_VK_DIVIDE: 0x6F;
11903 readonly DOM_VK_F1: 0x70;
11904 readonly DOM_VK_F2: 0x71;
11905 readonly DOM_VK_F3: 0x72;
11906 readonly DOM_VK_F4: 0x73;
11907 readonly DOM_VK_F5: 0x74;
11908 readonly DOM_VK_F6: 0x75;
11909 readonly DOM_VK_F7: 0x76;
11910 readonly DOM_VK_F8: 0x77;
11911 readonly DOM_VK_F9: 0x78;
11912 readonly DOM_VK_F10: 0x79;
11913 readonly DOM_VK_F11: 0x7A;
11914 readonly DOM_VK_F12: 0x7B;
11915 readonly DOM_VK_F13: 0x7C;
11916 readonly DOM_VK_F14: 0x7D;
11917 readonly DOM_VK_F15: 0x7E;
11918 readonly DOM_VK_F16: 0x7F;
11919 readonly DOM_VK_F17: 0x80;
11920 readonly DOM_VK_F18: 0x81;
11921 readonly DOM_VK_F19: 0x82;
11922 readonly DOM_VK_F20: 0x83;
11923 readonly DOM_VK_F21: 0x84;
11924 readonly DOM_VK_F22: 0x85;
11925 readonly DOM_VK_F23: 0x86;
11926 readonly DOM_VK_F24: 0x87;
11927 readonly DOM_VK_NUM_LOCK: 0x90;
11928 readonly DOM_VK_SCROLL_LOCK: 0x91;
11929 readonly DOM_VK_WIN_OEM_FJ_JISHO: 0x92;
11930 readonly DOM_VK_WIN_OEM_FJ_MASSHOU: 0x93;
11931 readonly DOM_VK_WIN_OEM_FJ_TOUROKU: 0x94;
11932 readonly DOM_VK_WIN_OEM_FJ_LOYA: 0x95;
11933 readonly DOM_VK_WIN_OEM_FJ_ROYA: 0x96;
11934 readonly DOM_VK_CIRCUMFLEX: 0xA0;
11935 readonly DOM_VK_EXCLAMATION: 0xA1;
11936 readonly DOM_VK_DOUBLE_QUOTE: 0xA2;
11937 readonly DOM_VK_HASH: 0xA3;
11938 readonly DOM_VK_DOLLAR: 0xA4;
11939 readonly DOM_VK_PERCENT: 0xA5;
11940 readonly DOM_VK_AMPERSAND: 0xA6;
11941 readonly DOM_VK_UNDERSCORE: 0xA7;
11942 readonly DOM_VK_OPEN_PAREN: 0xA8;
11943 readonly DOM_VK_CLOSE_PAREN: 0xA9;
11944 readonly DOM_VK_ASTERISK: 0xAA;
11945 readonly DOM_VK_PLUS: 0xAB;
11946 readonly DOM_VK_PIPE: 0xAC;
11947 readonly DOM_VK_HYPHEN_MINUS: 0xAD;
11948 readonly DOM_VK_OPEN_CURLY_BRACKET: 0xAE;
11949 readonly DOM_VK_CLOSE_CURLY_BRACKET: 0xAF;
11950 readonly DOM_VK_TILDE: 0xB0;
11951 readonly DOM_VK_VOLUME_MUTE: 0xB5;
11952 readonly DOM_VK_VOLUME_DOWN: 0xB6;
11953 readonly DOM_VK_VOLUME_UP: 0xB7;
11954 readonly DOM_VK_COMMA: 0xBC;
11955 readonly DOM_VK_PERIOD: 0xBE;
11956 readonly DOM_VK_SLASH: 0xBF;
11957 readonly DOM_VK_BACK_QUOTE: 0xC0;
11958 readonly DOM_VK_OPEN_BRACKET: 0xDB;
11959 readonly DOM_VK_BACK_SLASH: 0xDC;
11960 readonly DOM_VK_CLOSE_BRACKET: 0xDD;
11961 readonly DOM_VK_QUOTE: 0xDE;
11962 readonly DOM_VK_META: 0xE0;
11963 readonly DOM_VK_ALTGR: 0xE1;
11964 readonly DOM_VK_WIN_ICO_HELP: 0xE3;
11965 readonly DOM_VK_WIN_ICO_00: 0xE4;
11966 readonly DOM_VK_PROCESSKEY: 0xE5;
11967 readonly DOM_VK_WIN_ICO_CLEAR: 0xE6;
11968 readonly DOM_VK_WIN_OEM_RESET: 0xE9;
11969 readonly DOM_VK_WIN_OEM_JUMP: 0xEA;
11970 readonly DOM_VK_WIN_OEM_PA1: 0xEB;
11971 readonly DOM_VK_WIN_OEM_PA2: 0xEC;
11972 readonly DOM_VK_WIN_OEM_PA3: 0xED;
11973 readonly DOM_VK_WIN_OEM_WSCTRL: 0xEE;
11974 readonly DOM_VK_WIN_OEM_CUSEL: 0xEF;
11975 readonly DOM_VK_WIN_OEM_ATTN: 0xF0;
11976 readonly DOM_VK_WIN_OEM_FINISH: 0xF1;
11977 readonly DOM_VK_WIN_OEM_COPY: 0xF2;
11978 readonly DOM_VK_WIN_OEM_AUTO: 0xF3;
11979 readonly DOM_VK_WIN_OEM_ENLW: 0xF4;
11980 readonly DOM_VK_WIN_OEM_BACKTAB: 0xF5;
11981 readonly DOM_VK_ATTN: 0xF6;
11982 readonly DOM_VK_CRSEL: 0xF7;
11983 readonly DOM_VK_EXSEL: 0xF8;
11984 readonly DOM_VK_EREOF: 0xF9;
11985 readonly DOM_VK_PLAY: 0xFA;
11986 readonly DOM_VK_ZOOM: 0xFB;
11987 readonly DOM_VK_PA1: 0xFD;
11988 readonly DOM_VK_WIN_OEM_CLEAR: 0xFE;
11989 isInstance: IsInstance<KeyEvent>;
11992 interface KeyEventMixin {
11993 initKeyEvent(type: string, canBubble?: boolean, cancelable?: boolean, view?: Window | null, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean, keyCode?: number, charCode?: number): void;
11994 readonly DOM_VK_CANCEL: 0x03;
11995 readonly DOM_VK_HELP: 0x06;
11996 readonly DOM_VK_BACK_SPACE: 0x08;
11997 readonly DOM_VK_TAB: 0x09;
11998 readonly DOM_VK_CLEAR: 0x0C;
11999 readonly DOM_VK_RETURN: 0x0D;
12000 readonly DOM_VK_SHIFT: 0x10;
12001 readonly DOM_VK_CONTROL: 0x11;
12002 readonly DOM_VK_ALT: 0x12;
12003 readonly DOM_VK_PAUSE: 0x13;
12004 readonly DOM_VK_CAPS_LOCK: 0x14;
12005 readonly DOM_VK_KANA: 0x15;
12006 readonly DOM_VK_HANGUL: 0x15;
12007 readonly DOM_VK_EISU: 0x16;
12008 readonly DOM_VK_JUNJA: 0x17;
12009 readonly DOM_VK_FINAL: 0x18;
12010 readonly DOM_VK_HANJA: 0x19;
12011 readonly DOM_VK_KANJI: 0x19;
12012 readonly DOM_VK_ESCAPE: 0x1B;
12013 readonly DOM_VK_CONVERT: 0x1C;
12014 readonly DOM_VK_NONCONVERT: 0x1D;
12015 readonly DOM_VK_ACCEPT: 0x1E;
12016 readonly DOM_VK_MODECHANGE: 0x1F;
12017 readonly DOM_VK_SPACE: 0x20;
12018 readonly DOM_VK_PAGE_UP: 0x21;
12019 readonly DOM_VK_PAGE_DOWN: 0x22;
12020 readonly DOM_VK_END: 0x23;
12021 readonly DOM_VK_HOME: 0x24;
12022 readonly DOM_VK_LEFT: 0x25;
12023 readonly DOM_VK_UP: 0x26;
12024 readonly DOM_VK_RIGHT: 0x27;
12025 readonly DOM_VK_DOWN: 0x28;
12026 readonly DOM_VK_SELECT: 0x29;
12027 readonly DOM_VK_PRINT: 0x2A;
12028 readonly DOM_VK_EXECUTE: 0x2B;
12029 readonly DOM_VK_PRINTSCREEN: 0x2C;
12030 readonly DOM_VK_INSERT: 0x2D;
12031 readonly DOM_VK_DELETE: 0x2E;
12032 readonly DOM_VK_0: 0x30;
12033 readonly DOM_VK_1: 0x31;
12034 readonly DOM_VK_2: 0x32;
12035 readonly DOM_VK_3: 0x33;
12036 readonly DOM_VK_4: 0x34;
12037 readonly DOM_VK_5: 0x35;
12038 readonly DOM_VK_6: 0x36;
12039 readonly DOM_VK_7: 0x37;
12040 readonly DOM_VK_8: 0x38;
12041 readonly DOM_VK_9: 0x39;
12042 readonly DOM_VK_COLON: 0x3A;
12043 readonly DOM_VK_SEMICOLON: 0x3B;
12044 readonly DOM_VK_LESS_THAN: 0x3C;
12045 readonly DOM_VK_EQUALS: 0x3D;
12046 readonly DOM_VK_GREATER_THAN: 0x3E;
12047 readonly DOM_VK_QUESTION_MARK: 0x3F;
12048 readonly DOM_VK_AT: 0x40;
12049 readonly DOM_VK_A: 0x41;
12050 readonly DOM_VK_B: 0x42;
12051 readonly DOM_VK_C: 0x43;
12052 readonly DOM_VK_D: 0x44;
12053 readonly DOM_VK_E: 0x45;
12054 readonly DOM_VK_F: 0x46;
12055 readonly DOM_VK_G: 0x47;
12056 readonly DOM_VK_H: 0x48;
12057 readonly DOM_VK_I: 0x49;
12058 readonly DOM_VK_J: 0x4A;
12059 readonly DOM_VK_K: 0x4B;
12060 readonly DOM_VK_L: 0x4C;
12061 readonly DOM_VK_M: 0x4D;
12062 readonly DOM_VK_N: 0x4E;
12063 readonly DOM_VK_O: 0x4F;
12064 readonly DOM_VK_P: 0x50;
12065 readonly DOM_VK_Q: 0x51;
12066 readonly DOM_VK_R: 0x52;
12067 readonly DOM_VK_S: 0x53;
12068 readonly DOM_VK_T: 0x54;
12069 readonly DOM_VK_U: 0x55;
12070 readonly DOM_VK_V: 0x56;
12071 readonly DOM_VK_W: 0x57;
12072 readonly DOM_VK_X: 0x58;
12073 readonly DOM_VK_Y: 0x59;
12074 readonly DOM_VK_Z: 0x5A;
12075 readonly DOM_VK_WIN: 0x5B;
12076 readonly DOM_VK_CONTEXT_MENU: 0x5D;
12077 readonly DOM_VK_SLEEP: 0x5F;
12078 readonly DOM_VK_NUMPAD0: 0x60;
12079 readonly DOM_VK_NUMPAD1: 0x61;
12080 readonly DOM_VK_NUMPAD2: 0x62;
12081 readonly DOM_VK_NUMPAD3: 0x63;
12082 readonly DOM_VK_NUMPAD4: 0x64;
12083 readonly DOM_VK_NUMPAD5: 0x65;
12084 readonly DOM_VK_NUMPAD6: 0x66;
12085 readonly DOM_VK_NUMPAD7: 0x67;
12086 readonly DOM_VK_NUMPAD8: 0x68;
12087 readonly DOM_VK_NUMPAD9: 0x69;
12088 readonly DOM_VK_MULTIPLY: 0x6A;
12089 readonly DOM_VK_ADD: 0x6B;
12090 readonly DOM_VK_SEPARATOR: 0x6C;
12091 readonly DOM_VK_SUBTRACT: 0x6D;
12092 readonly DOM_VK_DECIMAL: 0x6E;
12093 readonly DOM_VK_DIVIDE: 0x6F;
12094 readonly DOM_VK_F1: 0x70;
12095 readonly DOM_VK_F2: 0x71;
12096 readonly DOM_VK_F3: 0x72;
12097 readonly DOM_VK_F4: 0x73;
12098 readonly DOM_VK_F5: 0x74;
12099 readonly DOM_VK_F6: 0x75;
12100 readonly DOM_VK_F7: 0x76;
12101 readonly DOM_VK_F8: 0x77;
12102 readonly DOM_VK_F9: 0x78;
12103 readonly DOM_VK_F10: 0x79;
12104 readonly DOM_VK_F11: 0x7A;
12105 readonly DOM_VK_F12: 0x7B;
12106 readonly DOM_VK_F13: 0x7C;
12107 readonly DOM_VK_F14: 0x7D;
12108 readonly DOM_VK_F15: 0x7E;
12109 readonly DOM_VK_F16: 0x7F;
12110 readonly DOM_VK_F17: 0x80;
12111 readonly DOM_VK_F18: 0x81;
12112 readonly DOM_VK_F19: 0x82;
12113 readonly DOM_VK_F20: 0x83;
12114 readonly DOM_VK_F21: 0x84;
12115 readonly DOM_VK_F22: 0x85;
12116 readonly DOM_VK_F23: 0x86;
12117 readonly DOM_VK_F24: 0x87;
12118 readonly DOM_VK_NUM_LOCK: 0x90;
12119 readonly DOM_VK_SCROLL_LOCK: 0x91;
12120 readonly DOM_VK_WIN_OEM_FJ_JISHO: 0x92;
12121 readonly DOM_VK_WIN_OEM_FJ_MASSHOU: 0x93;
12122 readonly DOM_VK_WIN_OEM_FJ_TOUROKU: 0x94;
12123 readonly DOM_VK_WIN_OEM_FJ_LOYA: 0x95;
12124 readonly DOM_VK_WIN_OEM_FJ_ROYA: 0x96;
12125 readonly DOM_VK_CIRCUMFLEX: 0xA0;
12126 readonly DOM_VK_EXCLAMATION: 0xA1;
12127 readonly DOM_VK_DOUBLE_QUOTE: 0xA2;
12128 readonly DOM_VK_HASH: 0xA3;
12129 readonly DOM_VK_DOLLAR: 0xA4;
12130 readonly DOM_VK_PERCENT: 0xA5;
12131 readonly DOM_VK_AMPERSAND: 0xA6;
12132 readonly DOM_VK_UNDERSCORE: 0xA7;
12133 readonly DOM_VK_OPEN_PAREN: 0xA8;
12134 readonly DOM_VK_CLOSE_PAREN: 0xA9;
12135 readonly DOM_VK_ASTERISK: 0xAA;
12136 readonly DOM_VK_PLUS: 0xAB;
12137 readonly DOM_VK_PIPE: 0xAC;
12138 readonly DOM_VK_HYPHEN_MINUS: 0xAD;
12139 readonly DOM_VK_OPEN_CURLY_BRACKET: 0xAE;
12140 readonly DOM_VK_CLOSE_CURLY_BRACKET: 0xAF;
12141 readonly DOM_VK_TILDE: 0xB0;
12142 readonly DOM_VK_VOLUME_MUTE: 0xB5;
12143 readonly DOM_VK_VOLUME_DOWN: 0xB6;
12144 readonly DOM_VK_VOLUME_UP: 0xB7;
12145 readonly DOM_VK_COMMA: 0xBC;
12146 readonly DOM_VK_PERIOD: 0xBE;
12147 readonly DOM_VK_SLASH: 0xBF;
12148 readonly DOM_VK_BACK_QUOTE: 0xC0;
12149 readonly DOM_VK_OPEN_BRACKET: 0xDB;
12150 readonly DOM_VK_BACK_SLASH: 0xDC;
12151 readonly DOM_VK_CLOSE_BRACKET: 0xDD;
12152 readonly DOM_VK_QUOTE: 0xDE;
12153 readonly DOM_VK_META: 0xE0;
12154 readonly DOM_VK_ALTGR: 0xE1;
12155 readonly DOM_VK_WIN_ICO_HELP: 0xE3;
12156 readonly DOM_VK_WIN_ICO_00: 0xE4;
12157 readonly DOM_VK_PROCESSKEY: 0xE5;
12158 readonly DOM_VK_WIN_ICO_CLEAR: 0xE6;
12159 readonly DOM_VK_WIN_OEM_RESET: 0xE9;
12160 readonly DOM_VK_WIN_OEM_JUMP: 0xEA;
12161 readonly DOM_VK_WIN_OEM_PA1: 0xEB;
12162 readonly DOM_VK_WIN_OEM_PA2: 0xEC;
12163 readonly DOM_VK_WIN_OEM_PA3: 0xED;
12164 readonly DOM_VK_WIN_OEM_WSCTRL: 0xEE;
12165 readonly DOM_VK_WIN_OEM_CUSEL: 0xEF;
12166 readonly DOM_VK_WIN_OEM_ATTN: 0xF0;
12167 readonly DOM_VK_WIN_OEM_FINISH: 0xF1;
12168 readonly DOM_VK_WIN_OEM_COPY: 0xF2;
12169 readonly DOM_VK_WIN_OEM_AUTO: 0xF3;
12170 readonly DOM_VK_WIN_OEM_ENLW: 0xF4;
12171 readonly DOM_VK_WIN_OEM_BACKTAB: 0xF5;
12172 readonly DOM_VK_ATTN: 0xF6;
12173 readonly DOM_VK_CRSEL: 0xF7;
12174 readonly DOM_VK_EXSEL: 0xF8;
12175 readonly DOM_VK_EREOF: 0xF9;
12176 readonly DOM_VK_PLAY: 0xFA;
12177 readonly DOM_VK_ZOOM: 0xFB;
12178 readonly DOM_VK_PA1: 0xFD;
12179 readonly DOM_VK_WIN_OEM_CLEAR: 0xFE;
12182 interface KeyboardEvent extends UIEvent, KeyEventMixin {
12183 readonly altKey: boolean;
12184 readonly charCode: number;
12185 readonly code: string;
12186 readonly ctrlKey: boolean;
12187 readonly initDict: KeyboardEventInit;
12188 readonly isComposing: boolean;
12189 readonly key: string;
12190 readonly keyCode: number;
12191 readonly location: number;
12192 readonly metaKey: boolean;
12193 readonly repeat: boolean;
12194 readonly shiftKey: boolean;
12195 getModifierState(key: string): boolean;
12196 initKeyboardEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, keyArg?: string, locationArg?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): void;
12197 readonly DOM_KEY_LOCATION_STANDARD: 0x00;
12198 readonly DOM_KEY_LOCATION_LEFT: 0x01;
12199 readonly DOM_KEY_LOCATION_RIGHT: 0x02;
12200 readonly DOM_KEY_LOCATION_NUMPAD: 0x03;
12203 declare var KeyboardEvent: {
12204 prototype: KeyboardEvent;
12205 new(typeArg: string, keyboardEventInitDict?: KeyboardEventInit): KeyboardEvent;
12206 readonly DOM_KEY_LOCATION_STANDARD: 0x00;
12207 readonly DOM_KEY_LOCATION_LEFT: 0x01;
12208 readonly DOM_KEY_LOCATION_RIGHT: 0x02;
12209 readonly DOM_KEY_LOCATION_NUMPAD: 0x03;
12210 readonly DOM_VK_CANCEL: 0x03;
12211 readonly DOM_VK_HELP: 0x06;
12212 readonly DOM_VK_BACK_SPACE: 0x08;
12213 readonly DOM_VK_TAB: 0x09;
12214 readonly DOM_VK_CLEAR: 0x0C;
12215 readonly DOM_VK_RETURN: 0x0D;
12216 readonly DOM_VK_SHIFT: 0x10;
12217 readonly DOM_VK_CONTROL: 0x11;
12218 readonly DOM_VK_ALT: 0x12;
12219 readonly DOM_VK_PAUSE: 0x13;
12220 readonly DOM_VK_CAPS_LOCK: 0x14;
12221 readonly DOM_VK_KANA: 0x15;
12222 readonly DOM_VK_HANGUL: 0x15;
12223 readonly DOM_VK_EISU: 0x16;
12224 readonly DOM_VK_JUNJA: 0x17;
12225 readonly DOM_VK_FINAL: 0x18;
12226 readonly DOM_VK_HANJA: 0x19;
12227 readonly DOM_VK_KANJI: 0x19;
12228 readonly DOM_VK_ESCAPE: 0x1B;
12229 readonly DOM_VK_CONVERT: 0x1C;
12230 readonly DOM_VK_NONCONVERT: 0x1D;
12231 readonly DOM_VK_ACCEPT: 0x1E;
12232 readonly DOM_VK_MODECHANGE: 0x1F;
12233 readonly DOM_VK_SPACE: 0x20;
12234 readonly DOM_VK_PAGE_UP: 0x21;
12235 readonly DOM_VK_PAGE_DOWN: 0x22;
12236 readonly DOM_VK_END: 0x23;
12237 readonly DOM_VK_HOME: 0x24;
12238 readonly DOM_VK_LEFT: 0x25;
12239 readonly DOM_VK_UP: 0x26;
12240 readonly DOM_VK_RIGHT: 0x27;
12241 readonly DOM_VK_DOWN: 0x28;
12242 readonly DOM_VK_SELECT: 0x29;
12243 readonly DOM_VK_PRINT: 0x2A;
12244 readonly DOM_VK_EXECUTE: 0x2B;
12245 readonly DOM_VK_PRINTSCREEN: 0x2C;
12246 readonly DOM_VK_INSERT: 0x2D;
12247 readonly DOM_VK_DELETE: 0x2E;
12248 readonly DOM_VK_0: 0x30;
12249 readonly DOM_VK_1: 0x31;
12250 readonly DOM_VK_2: 0x32;
12251 readonly DOM_VK_3: 0x33;
12252 readonly DOM_VK_4: 0x34;
12253 readonly DOM_VK_5: 0x35;
12254 readonly DOM_VK_6: 0x36;
12255 readonly DOM_VK_7: 0x37;
12256 readonly DOM_VK_8: 0x38;
12257 readonly DOM_VK_9: 0x39;
12258 readonly DOM_VK_COLON: 0x3A;
12259 readonly DOM_VK_SEMICOLON: 0x3B;
12260 readonly DOM_VK_LESS_THAN: 0x3C;
12261 readonly DOM_VK_EQUALS: 0x3D;
12262 readonly DOM_VK_GREATER_THAN: 0x3E;
12263 readonly DOM_VK_QUESTION_MARK: 0x3F;
12264 readonly DOM_VK_AT: 0x40;
12265 readonly DOM_VK_A: 0x41;
12266 readonly DOM_VK_B: 0x42;
12267 readonly DOM_VK_C: 0x43;
12268 readonly DOM_VK_D: 0x44;
12269 readonly DOM_VK_E: 0x45;
12270 readonly DOM_VK_F: 0x46;
12271 readonly DOM_VK_G: 0x47;
12272 readonly DOM_VK_H: 0x48;
12273 readonly DOM_VK_I: 0x49;
12274 readonly DOM_VK_J: 0x4A;
12275 readonly DOM_VK_K: 0x4B;
12276 readonly DOM_VK_L: 0x4C;
12277 readonly DOM_VK_M: 0x4D;
12278 readonly DOM_VK_N: 0x4E;
12279 readonly DOM_VK_O: 0x4F;
12280 readonly DOM_VK_P: 0x50;
12281 readonly DOM_VK_Q: 0x51;
12282 readonly DOM_VK_R: 0x52;
12283 readonly DOM_VK_S: 0x53;
12284 readonly DOM_VK_T: 0x54;
12285 readonly DOM_VK_U: 0x55;
12286 readonly DOM_VK_V: 0x56;
12287 readonly DOM_VK_W: 0x57;
12288 readonly DOM_VK_X: 0x58;
12289 readonly DOM_VK_Y: 0x59;
12290 readonly DOM_VK_Z: 0x5A;
12291 readonly DOM_VK_WIN: 0x5B;
12292 readonly DOM_VK_CONTEXT_MENU: 0x5D;
12293 readonly DOM_VK_SLEEP: 0x5F;
12294 readonly DOM_VK_NUMPAD0: 0x60;
12295 readonly DOM_VK_NUMPAD1: 0x61;
12296 readonly DOM_VK_NUMPAD2: 0x62;
12297 readonly DOM_VK_NUMPAD3: 0x63;
12298 readonly DOM_VK_NUMPAD4: 0x64;
12299 readonly DOM_VK_NUMPAD5: 0x65;
12300 readonly DOM_VK_NUMPAD6: 0x66;
12301 readonly DOM_VK_NUMPAD7: 0x67;
12302 readonly DOM_VK_NUMPAD8: 0x68;
12303 readonly DOM_VK_NUMPAD9: 0x69;
12304 readonly DOM_VK_MULTIPLY: 0x6A;
12305 readonly DOM_VK_ADD: 0x6B;
12306 readonly DOM_VK_SEPARATOR: 0x6C;
12307 readonly DOM_VK_SUBTRACT: 0x6D;
12308 readonly DOM_VK_DECIMAL: 0x6E;
12309 readonly DOM_VK_DIVIDE: 0x6F;
12310 readonly DOM_VK_F1: 0x70;
12311 readonly DOM_VK_F2: 0x71;
12312 readonly DOM_VK_F3: 0x72;
12313 readonly DOM_VK_F4: 0x73;
12314 readonly DOM_VK_F5: 0x74;
12315 readonly DOM_VK_F6: 0x75;
12316 readonly DOM_VK_F7: 0x76;
12317 readonly DOM_VK_F8: 0x77;
12318 readonly DOM_VK_F9: 0x78;
12319 readonly DOM_VK_F10: 0x79;
12320 readonly DOM_VK_F11: 0x7A;
12321 readonly DOM_VK_F12: 0x7B;
12322 readonly DOM_VK_F13: 0x7C;
12323 readonly DOM_VK_F14: 0x7D;
12324 readonly DOM_VK_F15: 0x7E;
12325 readonly DOM_VK_F16: 0x7F;
12326 readonly DOM_VK_F17: 0x80;
12327 readonly DOM_VK_F18: 0x81;
12328 readonly DOM_VK_F19: 0x82;
12329 readonly DOM_VK_F20: 0x83;
12330 readonly DOM_VK_F21: 0x84;
12331 readonly DOM_VK_F22: 0x85;
12332 readonly DOM_VK_F23: 0x86;
12333 readonly DOM_VK_F24: 0x87;
12334 readonly DOM_VK_NUM_LOCK: 0x90;
12335 readonly DOM_VK_SCROLL_LOCK: 0x91;
12336 readonly DOM_VK_WIN_OEM_FJ_JISHO: 0x92;
12337 readonly DOM_VK_WIN_OEM_FJ_MASSHOU: 0x93;
12338 readonly DOM_VK_WIN_OEM_FJ_TOUROKU: 0x94;
12339 readonly DOM_VK_WIN_OEM_FJ_LOYA: 0x95;
12340 readonly DOM_VK_WIN_OEM_FJ_ROYA: 0x96;
12341 readonly DOM_VK_CIRCUMFLEX: 0xA0;
12342 readonly DOM_VK_EXCLAMATION: 0xA1;
12343 readonly DOM_VK_DOUBLE_QUOTE: 0xA2;
12344 readonly DOM_VK_HASH: 0xA3;
12345 readonly DOM_VK_DOLLAR: 0xA4;
12346 readonly DOM_VK_PERCENT: 0xA5;
12347 readonly DOM_VK_AMPERSAND: 0xA6;
12348 readonly DOM_VK_UNDERSCORE: 0xA7;
12349 readonly DOM_VK_OPEN_PAREN: 0xA8;
12350 readonly DOM_VK_CLOSE_PAREN: 0xA9;
12351 readonly DOM_VK_ASTERISK: 0xAA;
12352 readonly DOM_VK_PLUS: 0xAB;
12353 readonly DOM_VK_PIPE: 0xAC;
12354 readonly DOM_VK_HYPHEN_MINUS: 0xAD;
12355 readonly DOM_VK_OPEN_CURLY_BRACKET: 0xAE;
12356 readonly DOM_VK_CLOSE_CURLY_BRACKET: 0xAF;
12357 readonly DOM_VK_TILDE: 0xB0;
12358 readonly DOM_VK_VOLUME_MUTE: 0xB5;
12359 readonly DOM_VK_VOLUME_DOWN: 0xB6;
12360 readonly DOM_VK_VOLUME_UP: 0xB7;
12361 readonly DOM_VK_COMMA: 0xBC;
12362 readonly DOM_VK_PERIOD: 0xBE;
12363 readonly DOM_VK_SLASH: 0xBF;
12364 readonly DOM_VK_BACK_QUOTE: 0xC0;
12365 readonly DOM_VK_OPEN_BRACKET: 0xDB;
12366 readonly DOM_VK_BACK_SLASH: 0xDC;
12367 readonly DOM_VK_CLOSE_BRACKET: 0xDD;
12368 readonly DOM_VK_QUOTE: 0xDE;
12369 readonly DOM_VK_META: 0xE0;
12370 readonly DOM_VK_ALTGR: 0xE1;
12371 readonly DOM_VK_WIN_ICO_HELP: 0xE3;
12372 readonly DOM_VK_WIN_ICO_00: 0xE4;
12373 readonly DOM_VK_PROCESSKEY: 0xE5;
12374 readonly DOM_VK_WIN_ICO_CLEAR: 0xE6;
12375 readonly DOM_VK_WIN_OEM_RESET: 0xE9;
12376 readonly DOM_VK_WIN_OEM_JUMP: 0xEA;
12377 readonly DOM_VK_WIN_OEM_PA1: 0xEB;
12378 readonly DOM_VK_WIN_OEM_PA2: 0xEC;
12379 readonly DOM_VK_WIN_OEM_PA3: 0xED;
12380 readonly DOM_VK_WIN_OEM_WSCTRL: 0xEE;
12381 readonly DOM_VK_WIN_OEM_CUSEL: 0xEF;
12382 readonly DOM_VK_WIN_OEM_ATTN: 0xF0;
12383 readonly DOM_VK_WIN_OEM_FINISH: 0xF1;
12384 readonly DOM_VK_WIN_OEM_COPY: 0xF2;
12385 readonly DOM_VK_WIN_OEM_AUTO: 0xF3;
12386 readonly DOM_VK_WIN_OEM_ENLW: 0xF4;
12387 readonly DOM_VK_WIN_OEM_BACKTAB: 0xF5;
12388 readonly DOM_VK_ATTN: 0xF6;
12389 readonly DOM_VK_CRSEL: 0xF7;
12390 readonly DOM_VK_EXSEL: 0xF8;
12391 readonly DOM_VK_EREOF: 0xF9;
12392 readonly DOM_VK_PLAY: 0xFA;
12393 readonly DOM_VK_ZOOM: 0xFB;
12394 readonly DOM_VK_PA1: 0xFD;
12395 readonly DOM_VK_WIN_OEM_CLEAR: 0xFE;
12396 isInstance: IsInstance<KeyboardEvent>;
12399 interface KeyframeEffect extends AnimationEffect {
12400 composite: CompositeOperation;
12401 iterationComposite: IterationCompositeOperation;
12402 pseudoElement: string | null;
12403 target: Element | null;
12404 getKeyframes(): any[];
12405 getProperties(): AnimationPropertyDetails[];
12406 setKeyframes(keyframes: any): void;
12409 declare var KeyframeEffect: {
12410 prototype: KeyframeEffect;
12411 new(target: Element | null, keyframes: any, options?: number | KeyframeEffectOptions): KeyframeEffect;
12412 new(source: KeyframeEffect): KeyframeEffect;
12413 isInstance: IsInstance<KeyframeEffect>;
12416 interface L10nFileSource {
12417 readonly index: string[] | null;
12418 readonly locales: string[];
12419 readonly metaSource: string;
12420 readonly name: string;
12421 readonly prePath: string;
12422 fetchFile(locale: string, path: string): Promise<FluentResource | null>;
12423 fetchFileSync(locale: string, path: string): FluentResource | null;
12424 hasFile(locale: string, path: string): L10nFileSourceHasFileStatus;
12427 declare var L10nFileSource: {
12428 prototype: L10nFileSource;
12429 new(name: string, metaSource: string, locales: string[], prePath: string, options?: FileSourceOptions, index?: string[]): L10nFileSource;
12430 isInstance: IsInstance<L10nFileSource>;
12431 createMock(name: string, metasource: string, locales: string[], prePath: string, fs: L10nFileSourceMockFile[]): L10nFileSource;
12434 interface L10nRegistry {
12435 clearSources(): void;
12436 generateBundles(aLocales: string[], aResourceIds: L10nResourceId[]): FluentBundleAsyncIterator;
12437 generateBundlesSync(aLocales: string[], aResourceIds: L10nResourceId[]): FluentBundleIterator;
12438 getAvailableLocales(): string[];
12439 getSource(aName: string): L10nFileSource | null;
12440 getSourceNames(): string[];
12441 hasSource(aName: string): boolean;
12442 registerSources(aSources: L10nFileSource[]): void;
12443 removeSources(aSources: string[]): void;
12444 updateSources(aSources: L10nFileSource[]): void;
12447 declare var L10nRegistry: {
12448 prototype: L10nRegistry;
12449 new(aOptions?: L10nRegistryOptions): L10nRegistry;
12450 isInstance: IsInstance<L10nRegistry>;
12451 getInstance(): L10nRegistry;
12454 interface LargestContentfulPaint extends PerformanceEntry {
12455 readonly element: Element | null;
12456 readonly id: string;
12457 readonly loadTime: DOMHighResTimeStamp;
12458 readonly renderTime: DOMHighResTimeStamp;
12459 readonly size: number;
12460 readonly url: string;
12464 declare var LargestContentfulPaint: {
12465 prototype: LargestContentfulPaint;
12466 new(): LargestContentfulPaint;
12467 isInstance: IsInstance<LargestContentfulPaint>;
12470 interface LegacyMozTCPSocket {
12471 listen(port: number, options?: ServerSocketOptions, backlog?: number): TCPServerSocket;
12472 open(host: string, port: number, options?: SocketOptions): TCPSocket;
12475 interface LinkStyle {
12476 readonly sheet: StyleSheet | null;
12479 interface LoadContext {
12482 interface LoadContextMixin {
12483 readonly associatedWindow: WindowProxy | null;
12484 readonly isContent: boolean;
12485 readonly originAttributes: any;
12486 readonly topFrameElement: Element | null;
12487 readonly topWindow: WindowProxy | null;
12488 usePrivateBrowsing: boolean;
12489 readonly useRemoteSubframes: boolean;
12490 readonly useRemoteTabs: boolean;
12491 useTrackingProtection: boolean;
12494 interface LoadInfo {
12497 interface Localization {
12498 addResourceIds(aResourceIds: L10nResourceId[]): void;
12499 formatMessages(aKeys: L10nKey[]): Promise<(L10nMessage | null)[]>;
12500 formatMessagesSync(aKeys: L10nKey[]): (L10nMessage | null)[];
12501 formatValue(aId: string, aArgs?: L10nArgs): Promise<string | null>;
12502 formatValueSync(aId: string, aArgs?: L10nArgs): string | null;
12503 formatValues(aKeys: L10nKey[]): Promise<(string | null)[]>;
12504 formatValuesSync(aKeys: L10nKey[]): (string | null)[];
12505 removeResourceIds(aResourceIds: L10nResourceId[]): number;
12509 declare var Localization: {
12510 prototype: Localization;
12511 new(aResourceIds: L10nResourceId[], aSync?: boolean, aRegistry?: L10nRegistry, aLocales?: string[]): Localization;
12512 isInstance: IsInstance<Localization>;
12515 interface Location {
12520 toString(): string;
12521 readonly origin: string;
12526 assign(url: string | URL): void;
12527 reload(forceget?: boolean): void;
12528 replace(url: string | URL): void;
12531 declare var Location: {
12532 prototype: Location;
12534 isInstance: IsInstance<Location>;
12537 /** Available only in secure contexts. */
12539 readonly mode: LockMode;
12540 readonly name: string;
12543 declare var Lock: {
12546 isInstance: IsInstance<Lock>;
12549 /** Available only in secure contexts. */
12550 interface LockManager {
12551 query(): Promise<LockManagerSnapshot>;
12552 request(name: string, callback: LockGrantedCallback): Promise<any>;
12553 request(name: string, options: LockOptions, callback: LockGrantedCallback): Promise<any>;
12556 declare var LockManager: {
12557 prototype: LockManager;
12558 new(): LockManager;
12559 isInstance: IsInstance<LockManager>;
12562 interface MIDIAccessEventMap {
12563 "statechange": Event;
12566 /** Available only in secure contexts. */
12567 interface MIDIAccess extends EventTarget {
12568 readonly inputs: MIDIInputMap;
12569 onstatechange: ((this: MIDIAccess, ev: Event) => any) | null;
12570 readonly outputs: MIDIOutputMap;
12571 readonly sysexEnabled: boolean;
12572 addEventListener<K extends keyof MIDIAccessEventMap>(type: K, listener: (this: MIDIAccess, ev: MIDIAccessEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12573 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12574 removeEventListener<K extends keyof MIDIAccessEventMap>(type: K, listener: (this: MIDIAccess, ev: MIDIAccessEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12575 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12578 declare var MIDIAccess: {
12579 prototype: MIDIAccess;
12581 isInstance: IsInstance<MIDIAccess>;
12584 /** Available only in secure contexts. */
12585 interface MIDIConnectionEvent extends Event {
12586 readonly port: MIDIPort | null;
12589 declare var MIDIConnectionEvent: {
12590 prototype: MIDIConnectionEvent;
12591 new(type: string, eventInitDict?: MIDIConnectionEventInit): MIDIConnectionEvent;
12592 isInstance: IsInstance<MIDIConnectionEvent>;
12595 interface MIDIInputEventMap extends MIDIPortEventMap {
12596 "midimessage": Event;
12599 /** Available only in secure contexts. */
12600 interface MIDIInput extends MIDIPort {
12601 onmidimessage: ((this: MIDIInput, ev: Event) => any) | null;
12602 addEventListener<K extends keyof MIDIInputEventMap>(type: K, listener: (this: MIDIInput, ev: MIDIInputEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12603 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12604 removeEventListener<K extends keyof MIDIInputEventMap>(type: K, listener: (this: MIDIInput, ev: MIDIInputEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12605 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12608 declare var MIDIInput: {
12609 prototype: MIDIInput;
12611 isInstance: IsInstance<MIDIInput>;
12614 /** Available only in secure contexts. */
12615 interface MIDIInputMap {
12616 forEach(callbackfn: (value: MIDIInput, key: string, parent: MIDIInputMap) => void, thisArg?: any): void;
12619 declare var MIDIInputMap: {
12620 prototype: MIDIInputMap;
12621 new(): MIDIInputMap;
12622 isInstance: IsInstance<MIDIInputMap>;
12625 /** Available only in secure contexts. */
12626 interface MIDIMessageEvent extends Event {
12627 readonly data: Uint8Array;
12630 declare var MIDIMessageEvent: {
12631 prototype: MIDIMessageEvent;
12632 new(type: string, eventInitDict?: MIDIMessageEventInit): MIDIMessageEvent;
12633 isInstance: IsInstance<MIDIMessageEvent>;
12636 /** Available only in secure contexts. */
12637 interface MIDIOutput extends MIDIPort {
12639 send(data: number[], timestamp?: DOMHighResTimeStamp): void;
12640 addEventListener<K extends keyof MIDIPortEventMap>(type: K, listener: (this: MIDIOutput, ev: MIDIPortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12641 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12642 removeEventListener<K extends keyof MIDIPortEventMap>(type: K, listener: (this: MIDIOutput, ev: MIDIPortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12643 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12646 declare var MIDIOutput: {
12647 prototype: MIDIOutput;
12649 isInstance: IsInstance<MIDIOutput>;
12652 /** Available only in secure contexts. */
12653 interface MIDIOutputMap {
12654 forEach(callbackfn: (value: MIDIOutput, key: string, parent: MIDIOutputMap) => void, thisArg?: any): void;
12657 declare var MIDIOutputMap: {
12658 prototype: MIDIOutputMap;
12659 new(): MIDIOutputMap;
12660 isInstance: IsInstance<MIDIOutputMap>;
12663 interface MIDIPortEventMap {
12664 "statechange": Event;
12667 /** Available only in secure contexts. */
12668 interface MIDIPort extends EventTarget {
12669 readonly connection: MIDIPortConnectionState;
12670 readonly id: string;
12671 readonly manufacturer: string | null;
12672 readonly name: string | null;
12673 onstatechange: ((this: MIDIPort, ev: Event) => any) | null;
12674 readonly state: MIDIPortDeviceState;
12675 readonly type: MIDIPortType;
12676 readonly version: string | null;
12677 close(): Promise<MIDIPort>;
12678 open(): Promise<MIDIPort>;
12679 addEventListener<K extends keyof MIDIPortEventMap>(type: K, listener: (this: MIDIPort, ev: MIDIPortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12680 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12681 removeEventListener<K extends keyof MIDIPortEventMap>(type: K, listener: (this: MIDIPort, ev: MIDIPortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12682 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12685 declare var MIDIPort: {
12686 prototype: MIDIPort;
12688 isInstance: IsInstance<MIDIPort>;
12691 interface MOZ_debug {
12692 getParameter(pname: GLenum): any;
12693 readonly EXTENSIONS: 0x1F03;
12694 readonly WSI_INFO: 0x10000;
12695 readonly UNPACK_REQUIRE_FASTPATH: 0x10001;
12696 readonly DOES_INDEX_VALIDATION: 0x10002;
12699 interface MatchGlob {
12700 readonly glob: string;
12701 matches(string: string): boolean;
12704 declare var MatchGlob: {
12705 prototype: MatchGlob;
12706 new(glob: string, allowQuestion?: boolean): MatchGlob;
12707 isInstance: IsInstance<MatchGlob>;
12710 interface MatchPattern {
12711 readonly matchesAllWebUrls: boolean;
12712 readonly pattern: string;
12713 matches(uri: URI, explicit?: boolean): boolean;
12714 matches(url: string, explicit?: boolean): boolean;
12715 matchesCookie(cookie: Cookie): boolean;
12716 overlaps(pattern: MatchPattern): boolean;
12717 subsumes(pattern: MatchPattern): boolean;
12718 subsumesDomain(pattern: MatchPattern): boolean;
12721 declare var MatchPattern: {
12722 prototype: MatchPattern;
12723 new(pattern: string, options?: MatchPatternOptions): MatchPattern;
12724 isInstance: IsInstance<MatchPattern>;
12727 interface MatchPatternSet {
12728 readonly matchesAllWebUrls: boolean;
12729 readonly patterns: MatchPattern[];
12730 matches(uri: URI, explicit?: boolean): boolean;
12731 matches(url: string, explicit?: boolean): boolean;
12732 matchesCookie(cookie: Cookie): boolean;
12733 overlaps(pattern: MatchPattern): boolean;
12734 overlaps(patternSet: MatchPatternSet): boolean;
12735 overlapsAll(patternSet: MatchPatternSet): boolean;
12736 subsumes(pattern: MatchPattern): boolean;
12737 subsumesDomain(pattern: MatchPattern): boolean;
12740 declare var MatchPatternSet: {
12741 prototype: MatchPatternSet;
12742 new(patterns: (string | MatchPattern)[], options?: MatchPatternOptions): MatchPatternSet;
12743 isInstance: IsInstance<MatchPatternSet>;
12746 interface MathMLElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, OnErrorEventHandlerForNodesEventMap, TouchEventHandlersEventMap {
12749 interface MathMLElement extends Element, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrForeignElement, OnErrorEventHandlerForNodes, TouchEventHandlers {
12750 addEventListener<K extends keyof MathMLElementEventMap>(type: K, listener: (this: MathMLElement, ev: MathMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12751 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12752 removeEventListener<K extends keyof MathMLElementEventMap>(type: K, listener: (this: MathMLElement, ev: MathMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12753 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12756 declare var MathMLElement: {
12757 prototype: MathMLElement;
12758 new(): MathMLElement;
12759 isInstance: IsInstance<MathMLElement>;
12762 interface MediaCapabilities {
12763 decodingInfo(configuration: MediaDecodingConfiguration): Promise<MediaCapabilitiesInfo>;
12764 encodingInfo(configuration: MediaEncodingConfiguration): Promise<MediaCapabilitiesInfo>;
12767 declare var MediaCapabilities: {
12768 prototype: MediaCapabilities;
12769 new(): MediaCapabilities;
12770 isInstance: IsInstance<MediaCapabilities>;
12773 interface MediaCapabilitiesInfo {
12774 readonly powerEfficient: boolean;
12775 readonly smooth: boolean;
12776 readonly supported: boolean;
12779 declare var MediaCapabilitiesInfo: {
12780 prototype: MediaCapabilitiesInfo;
12781 new(): MediaCapabilitiesInfo;
12782 isInstance: IsInstance<MediaCapabilitiesInfo>;
12785 interface MediaControllerEventMap {
12786 "activated": Event;
12787 "deactivated": Event;
12788 "metadatachange": Event;
12789 "playbackstatechange": Event;
12790 "positionstatechange": Event;
12791 "supportedkeyschange": Event;
12794 interface MediaController extends EventTarget {
12795 readonly id: number;
12796 readonly isActive: boolean;
12797 readonly isAudible: boolean;
12798 readonly isPlaying: boolean;
12799 onactivated: ((this: MediaController, ev: Event) => any) | null;
12800 ondeactivated: ((this: MediaController, ev: Event) => any) | null;
12801 onmetadatachange: ((this: MediaController, ev: Event) => any) | null;
12802 onplaybackstatechange: ((this: MediaController, ev: Event) => any) | null;
12803 onpositionstatechange: ((this: MediaController, ev: Event) => any) | null;
12804 onsupportedkeyschange: ((this: MediaController, ev: Event) => any) | null;
12805 readonly playbackState: MediaSessionPlaybackState;
12806 readonly supportedKeys: MediaControlKey[];
12808 getMetadata(): MediaMetadataInit;
12813 seekBackward(): void;
12814 seekForward(): void;
12815 seekTo(seekTime: number, fastSeek?: boolean): void;
12818 addEventListener<K extends keyof MediaControllerEventMap>(type: K, listener: (this: MediaController, ev: MediaControllerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12819 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12820 removeEventListener<K extends keyof MediaControllerEventMap>(type: K, listener: (this: MediaController, ev: MediaControllerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12821 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12824 declare var MediaController: {
12825 prototype: MediaController;
12826 new(): MediaController;
12827 isInstance: IsInstance<MediaController>;
12830 interface MediaDeviceInfo {
12831 readonly deviceId: string;
12832 readonly groupId: string;
12833 readonly kind: MediaDeviceKind;
12834 readonly label: string;
12838 declare var MediaDeviceInfo: {
12839 prototype: MediaDeviceInfo;
12840 new(): MediaDeviceInfo;
12841 isInstance: IsInstance<MediaDeviceInfo>;
12844 interface MediaDevicesEventMap {
12845 "devicechange": Event;
12848 interface MediaDevices extends EventTarget {
12849 ondevicechange: ((this: MediaDevices, ev: Event) => any) | null;
12850 enumerateDevices(): Promise<MediaDeviceInfo[]>;
12851 /** Available only in secure contexts. */
12852 getDisplayMedia(constraints?: DisplayMediaStreamConstraints): Promise<MediaStream>;
12853 getSupportedConstraints(): MediaTrackSupportedConstraints;
12854 getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
12855 /** Available only in secure contexts. */
12856 selectAudioOutput(options?: AudioOutputOptions): Promise<MediaDeviceInfo>;
12857 addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12858 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12859 removeEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12860 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12863 declare var MediaDevices: {
12864 prototype: MediaDevices;
12865 new(): MediaDevices;
12866 isInstance: IsInstance<MediaDevices>;
12869 interface MediaElementAudioSourceNode extends AudioNode, AudioNodePassThrough {
12870 readonly mediaElement: HTMLMediaElement;
12873 declare var MediaElementAudioSourceNode: {
12874 prototype: MediaElementAudioSourceNode;
12875 new(context: AudioContext, options: MediaElementAudioSourceOptions): MediaElementAudioSourceNode;
12876 isInstance: IsInstance<MediaElementAudioSourceNode>;
12879 interface MediaEncryptedEvent extends Event {
12880 readonly initData: ArrayBuffer | null;
12881 readonly initDataType: string;
12884 declare var MediaEncryptedEvent: {
12885 prototype: MediaEncryptedEvent;
12886 new(type: string, eventInitDict?: MediaKeyNeededEventInit): MediaEncryptedEvent;
12887 isInstance: IsInstance<MediaEncryptedEvent>;
12890 interface MediaError {
12891 readonly code: number;
12892 readonly message: string;
12893 readonly MEDIA_ERR_ABORTED: 1;
12894 readonly MEDIA_ERR_NETWORK: 2;
12895 readonly MEDIA_ERR_DECODE: 3;
12896 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: 4;
12899 declare var MediaError: {
12900 prototype: MediaError;
12902 readonly MEDIA_ERR_ABORTED: 1;
12903 readonly MEDIA_ERR_NETWORK: 2;
12904 readonly MEDIA_ERR_DECODE: 3;
12905 readonly MEDIA_ERR_SRC_NOT_SUPPORTED: 4;
12906 isInstance: IsInstance<MediaError>;
12909 interface MediaKeyError extends Event {
12910 readonly systemCode: number;
12913 declare var MediaKeyError: {
12914 prototype: MediaKeyError;
12915 new(): MediaKeyError;
12916 isInstance: IsInstance<MediaKeyError>;
12919 interface MediaKeyMessageEvent extends Event {
12920 readonly message: ArrayBuffer;
12921 readonly messageType: MediaKeyMessageType;
12924 declare var MediaKeyMessageEvent: {
12925 prototype: MediaKeyMessageEvent;
12926 new(type: string, eventInitDict: MediaKeyMessageEventInit): MediaKeyMessageEvent;
12927 isInstance: IsInstance<MediaKeyMessageEvent>;
12930 interface MediaKeySessionEventMap {
12931 "keystatuseschange": Event;
12935 interface MediaKeySession extends EventTarget {
12936 readonly closed: Promise<undefined>;
12937 readonly error: MediaKeyError | null;
12938 readonly expiration: number;
12939 readonly keyStatuses: MediaKeyStatusMap;
12940 onkeystatuseschange: ((this: MediaKeySession, ev: Event) => any) | null;
12941 onmessage: ((this: MediaKeySession, ev: Event) => any) | null;
12942 readonly sessionId: string;
12943 close(): Promise<void>;
12944 generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
12945 load(sessionId: string): Promise<boolean>;
12946 remove(): Promise<void>;
12947 update(response: BufferSource): Promise<void>;
12948 addEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
12949 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
12950 removeEventListener<K extends keyof MediaKeySessionEventMap>(type: K, listener: (this: MediaKeySession, ev: MediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
12951 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
12954 declare var MediaKeySession: {
12955 prototype: MediaKeySession;
12956 new(): MediaKeySession;
12957 isInstance: IsInstance<MediaKeySession>;
12960 interface MediaKeyStatusMap {
12961 readonly size: number;
12962 get(keyId: BufferSource): MediaKeyStatus | undefined;
12963 has(keyId: BufferSource): boolean;
12964 forEach(callbackfn: (value: MediaKeyStatus, key: ArrayBuffer, parent: MediaKeyStatusMap) => void, thisArg?: any): void;
12967 declare var MediaKeyStatusMap: {
12968 prototype: MediaKeyStatusMap;
12969 new(): MediaKeyStatusMap;
12970 isInstance: IsInstance<MediaKeyStatusMap>;
12973 interface MediaKeySystemAccess {
12974 readonly keySystem: string;
12975 createMediaKeys(): Promise<MediaKeys>;
12976 getConfiguration(): MediaKeySystemConfiguration;
12979 declare var MediaKeySystemAccess: {
12980 prototype: MediaKeySystemAccess;
12981 new(): MediaKeySystemAccess;
12982 isInstance: IsInstance<MediaKeySystemAccess>;
12985 interface MediaKeys {
12986 readonly keySystem: string;
12987 createSession(sessionType?: MediaKeySessionType): MediaKeySession;
12988 getStatusForPolicy(policy?: MediaKeysPolicy): Promise<MediaKeyStatus>;
12989 setServerCertificate(serverCertificate: BufferSource): Promise<void>;
12992 declare var MediaKeys: {
12993 prototype: MediaKeys;
12995 isInstance: IsInstance<MediaKeys>;
12998 interface MediaList {
12999 readonly length: number;
13001 toString(): string;
13002 appendMedium(newMedium: string): void;
13003 deleteMedium(oldMedium: string): void;
13004 item(index: number): string | null;
13005 [index: number]: string;
13008 declare var MediaList: {
13009 prototype: MediaList;
13011 isInstance: IsInstance<MediaList>;
13014 interface MediaMetadata {
13021 declare var MediaMetadata: {
13022 prototype: MediaMetadata;
13023 new(init?: MediaMetadataInit): MediaMetadata;
13024 isInstance: IsInstance<MediaMetadata>;
13027 interface MediaQueryListEventMap {
13031 interface MediaQueryList extends EventTarget {
13032 readonly matches: boolean;
13033 readonly media: string;
13034 onchange: ((this: MediaQueryList, ev: Event) => any) | null;
13035 addListener(listener: EventListener | null): void;
13036 removeListener(listener: EventListener | null): void;
13037 addEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13038 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13039 removeEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13040 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13043 declare var MediaQueryList: {
13044 prototype: MediaQueryList;
13045 new(): MediaQueryList;
13046 isInstance: IsInstance<MediaQueryList>;
13049 interface MediaQueryListEvent extends Event {
13050 readonly matches: boolean;
13051 readonly media: string;
13054 declare var MediaQueryListEvent: {
13055 prototype: MediaQueryListEvent;
13056 new(type: string, eventInitDict?: MediaQueryListEventInit): MediaQueryListEvent;
13057 isInstance: IsInstance<MediaQueryListEvent>;
13060 interface MediaRecorderEventMap {
13061 "dataavailable": Event;
13069 interface MediaRecorder extends EventTarget {
13070 readonly audioBitsPerSecond: number;
13071 readonly mimeType: string;
13072 ondataavailable: ((this: MediaRecorder, ev: Event) => any) | null;
13073 onerror: ((this: MediaRecorder, ev: Event) => any) | null;
13074 onpause: ((this: MediaRecorder, ev: Event) => any) | null;
13075 onresume: ((this: MediaRecorder, ev: Event) => any) | null;
13076 onstart: ((this: MediaRecorder, ev: Event) => any) | null;
13077 onstop: ((this: MediaRecorder, ev: Event) => any) | null;
13078 readonly state: RecordingState;
13079 readonly stream: MediaStream;
13080 readonly videoBitsPerSecond: number;
13082 requestData(): void;
13084 start(timeslice?: number): void;
13086 addEventListener<K extends keyof MediaRecorderEventMap>(type: K, listener: (this: MediaRecorder, ev: MediaRecorderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13087 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13088 removeEventListener<K extends keyof MediaRecorderEventMap>(type: K, listener: (this: MediaRecorder, ev: MediaRecorderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13089 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13092 declare var MediaRecorder: {
13093 prototype: MediaRecorder;
13094 new(stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
13095 new(node: AudioNode, output?: number, options?: MediaRecorderOptions): MediaRecorder;
13096 isInstance: IsInstance<MediaRecorder>;
13097 isTypeSupported(type: string): boolean;
13100 interface MediaRecorderErrorEvent extends Event {
13101 readonly error: DOMException;
13104 declare var MediaRecorderErrorEvent: {
13105 prototype: MediaRecorderErrorEvent;
13106 new(type: string, eventInitDict: MediaRecorderErrorEventInit): MediaRecorderErrorEvent;
13107 isInstance: IsInstance<MediaRecorderErrorEvent>;
13110 interface MediaSession {
13111 metadata: MediaMetadata | null;
13112 playbackState: MediaSessionPlaybackState;
13113 notifyHandler(details: MediaSessionActionDetails): void;
13114 setActionHandler(action: MediaSessionAction, handler: MediaSessionActionHandler | null): void;
13115 setPositionState(state?: MediaPositionState): void;
13118 declare var MediaSession: {
13119 prototype: MediaSession;
13120 new(): MediaSession;
13121 isInstance: IsInstance<MediaSession>;
13124 interface MediaSourceEventMap {
13125 "sourceclose": Event;
13126 "sourceended": Event;
13127 "sourceopen": Event;
13130 interface MediaSource extends EventTarget {
13131 readonly activeSourceBuffers: SourceBufferList;
13133 onsourceclose: ((this: MediaSource, ev: Event) => any) | null;
13134 onsourceended: ((this: MediaSource, ev: Event) => any) | null;
13135 onsourceopen: ((this: MediaSource, ev: Event) => any) | null;
13136 readonly readyState: MediaSourceReadyState;
13137 readonly sourceBuffers: SourceBufferList;
13138 addSourceBuffer(type: string): SourceBuffer;
13139 clearLiveSeekableRange(): void;
13140 endOfStream(error?: MediaSourceEndOfStreamError): void;
13141 mozDebugReaderData(): Promise<MediaSourceDecoderDebugInfo>;
13142 removeSourceBuffer(sourceBuffer: SourceBuffer): void;
13143 setLiveSeekableRange(start: number, end: number): void;
13144 addEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13145 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13146 removeEventListener<K extends keyof MediaSourceEventMap>(type: K, listener: (this: MediaSource, ev: MediaSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13147 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13150 declare var MediaSource: {
13151 prototype: MediaSource;
13152 new(): MediaSource;
13153 isInstance: IsInstance<MediaSource>;
13154 isTypeSupported(type: string): boolean;
13157 interface MediaStreamEventMap {
13159 "removetrack": Event;
13162 interface MediaStream extends EventTarget {
13163 readonly active: boolean;
13164 readonly id: string;
13165 onaddtrack: ((this: MediaStream, ev: Event) => any) | null;
13166 onremovetrack: ((this: MediaStream, ev: Event) => any) | null;
13167 addTrack(track: MediaStreamTrack): void;
13168 assignId(id: string): void;
13169 clone(): MediaStream;
13170 getAudioTracks(): MediaStreamTrack[];
13171 getTrackById(trackId: string): MediaStreamTrack | null;
13172 getTracks(): MediaStreamTrack[];
13173 getVideoTracks(): MediaStreamTrack[];
13174 removeTrack(track: MediaStreamTrack): void;
13175 addEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13176 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13177 removeEventListener<K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13178 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13181 declare var MediaStream: {
13182 prototype: MediaStream;
13183 new(): MediaStream;
13184 new(stream: MediaStream): MediaStream;
13185 new(tracks: MediaStreamTrack[]): MediaStream;
13186 isInstance: IsInstance<MediaStream>;
13187 countUnderlyingStreams(): Promise<number>;
13190 interface MediaStreamAudioDestinationNode extends AudioNode {
13191 readonly stream: MediaStream;
13194 declare var MediaStreamAudioDestinationNode: {
13195 prototype: MediaStreamAudioDestinationNode;
13196 new(context: AudioContext, options?: AudioNodeOptions): MediaStreamAudioDestinationNode;
13197 isInstance: IsInstance<MediaStreamAudioDestinationNode>;
13200 interface MediaStreamAudioSourceNode extends AudioNode, AudioNodePassThrough {
13201 readonly mediaStream: MediaStream;
13204 declare var MediaStreamAudioSourceNode: {
13205 prototype: MediaStreamAudioSourceNode;
13206 new(context: AudioContext, options: MediaStreamAudioSourceOptions): MediaStreamAudioSourceNode;
13207 isInstance: IsInstance<MediaStreamAudioSourceNode>;
13210 interface MediaStreamError {
13211 readonly constraint: string | null;
13212 readonly message: string | null;
13213 readonly name: string;
13216 interface MediaStreamEvent extends Event {
13217 readonly stream: MediaStream | null;
13220 declare var MediaStreamEvent: {
13221 prototype: MediaStreamEvent;
13222 new(type: string, eventInitDict?: MediaStreamEventInit): MediaStreamEvent;
13223 isInstance: IsInstance<MediaStreamEvent>;
13226 interface MediaStreamTrackEventMap {
13232 interface MediaStreamTrack extends EventTarget {
13234 readonly id: string;
13235 readonly kind: string;
13236 readonly label: string;
13237 readonly muted: boolean;
13238 onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
13239 onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
13240 onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
13241 readonly readyState: MediaStreamTrackState;
13242 applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
13243 clone(): MediaStreamTrack;
13244 getConstraints(): MediaTrackConstraints;
13245 getSettings(): MediaTrackSettings;
13247 addEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13248 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13249 removeEventListener<K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13250 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13253 declare var MediaStreamTrack: {
13254 prototype: MediaStreamTrack;
13255 new(): MediaStreamTrack;
13256 isInstance: IsInstance<MediaStreamTrack>;
13259 interface MediaStreamTrackAudioSourceNode extends AudioNode, AudioNodePassThrough {
13262 declare var MediaStreamTrackAudioSourceNode: {
13263 prototype: MediaStreamTrackAudioSourceNode;
13264 new(context: AudioContext, options: MediaStreamTrackAudioSourceOptions): MediaStreamTrackAudioSourceNode;
13265 isInstance: IsInstance<MediaStreamTrackAudioSourceNode>;
13268 interface MediaStreamTrackEvent extends Event {
13269 readonly track: MediaStreamTrack;
13272 declare var MediaStreamTrackEvent: {
13273 prototype: MediaStreamTrackEvent;
13274 new(type: string, eventInitDict: MediaStreamTrackEventInit): MediaStreamTrackEvent;
13275 isInstance: IsInstance<MediaStreamTrackEvent>;
13278 /** Available only in secure contexts. */
13279 interface MerchantValidationEvent extends Event {
13280 readonly methodName: string;
13281 readonly validationURL: string;
13282 complete(merchantSessionPromise: any): void;
13285 declare var MerchantValidationEvent: {
13286 prototype: MerchantValidationEvent;
13287 new(type: string, eventInitDict?: MerchantValidationEventInit): MerchantValidationEvent;
13288 isInstance: IsInstance<MerchantValidationEvent>;
13291 interface MessageBroadcaster extends MessageListenerManager {
13292 readonly childCount: number;
13293 broadcastAsyncMessage(messageName?: string | null, obj?: any): void;
13294 getChildAt(aIndex: number): MessageListenerManager | null;
13295 releaseCachedProcesses(): void;
13298 declare var MessageBroadcaster: {
13299 prototype: MessageBroadcaster;
13300 new(): MessageBroadcaster;
13301 isInstance: IsInstance<MessageBroadcaster>;
13304 interface MessageChannel {
13305 readonly port1: MessagePort;
13306 readonly port2: MessagePort;
13309 declare var MessageChannel: {
13310 prototype: MessageChannel;
13311 new(): MessageChannel;
13312 isInstance: IsInstance<MessageChannel>;
13315 interface MessageEvent extends Event {
13316 readonly data: any;
13317 readonly lastEventId: string;
13318 readonly origin: string;
13319 readonly ports: MessagePort[];
13320 readonly source: MessageEventSource | null;
13321 initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
13324 declare var MessageEvent: {
13325 prototype: MessageEvent;
13326 new(type: string, eventInitDict?: MessageEventInit): MessageEvent;
13327 isInstance: IsInstance<MessageEvent>;
13330 interface MessageListenerManager extends MessageListenerManagerMixin {
13333 declare var MessageListenerManager: {
13334 prototype: MessageListenerManager;
13335 new(): MessageListenerManager;
13336 isInstance: IsInstance<MessageListenerManager>;
13339 interface MessageListenerManagerMixin {
13340 addMessageListener(messageName: string, listener: MessageListener, listenWhenClosed?: boolean): void;
13341 addWeakMessageListener(messageName: string, listener: MessageListener): void;
13342 removeMessageListener(messageName: string, listener: MessageListener): void;
13343 removeWeakMessageListener(messageName: string, listener: MessageListener): void;
13346 interface MessageManagerGlobal {
13347 atob(asciiString: string): string;
13348 btoa(base64Data: string): string;
13349 dump(str: string): void;
13352 interface MessagePortEventMap {
13354 "messageerror": Event;
13357 interface MessagePort extends EventTarget {
13358 onmessage: ((this: MessagePort, ev: Event) => any) | null;
13359 onmessageerror: ((this: MessagePort, ev: Event) => any) | null;
13361 postMessage(message: any, transferable: any[]): void;
13362 postMessage(message: any, options?: StructuredSerializeOptions): void;
13364 addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13365 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13366 removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13367 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13370 declare var MessagePort: {
13371 prototype: MessagePort;
13372 new(): MessagePort;
13373 isInstance: IsInstance<MessagePort>;
13376 interface MessageSender extends MessageListenerManager, MessageSenderMixin {
13379 declare var MessageSender: {
13380 prototype: MessageSender;
13381 new(): MessageSender;
13382 isInstance: IsInstance<MessageSender>;
13385 interface MessageSenderMixin {
13386 readonly processMessageManager: MessageSender | null;
13387 readonly remoteType: string;
13388 sendAsyncMessage(messageName?: string | null, obj?: any, transfers?: any): void;
13391 interface MimeType {
13392 readonly description: string;
13393 readonly enabledPlugin: Plugin;
13394 readonly suffixes: string;
13395 readonly type: string;
13398 declare var MimeType: {
13399 prototype: MimeType;
13401 isInstance: IsInstance<MimeType>;
13404 interface MimeTypeArray {
13405 readonly length: number;
13406 item(index: number): MimeType | null;
13407 namedItem(name: string): MimeType | null;
13408 [index: number]: MimeType;
13411 declare var MimeTypeArray: {
13412 prototype: MimeTypeArray;
13413 new(): MimeTypeArray;
13414 isInstance: IsInstance<MimeTypeArray>;
13417 interface MouseEvent extends UIEvent {
13418 readonly altKey: boolean;
13419 readonly button: number;
13420 readonly buttons: number;
13421 readonly clientX: number;
13422 readonly clientY: number;
13423 readonly ctrlKey: boolean;
13424 readonly inputSource: number;
13425 readonly metaKey: boolean;
13426 readonly movementX: number;
13427 readonly movementY: number;
13428 readonly mozInputSource: number;
13429 readonly mozPressure: number;
13430 readonly offsetX: number;
13431 readonly offsetY: number;
13432 readonly pageX: number;
13433 readonly pageY: number;
13434 readonly relatedTarget: EventTarget | null;
13435 readonly screen: nsIScreen | null;
13436 readonly screenX: number;
13437 readonly screenY: number;
13438 readonly shiftKey: boolean;
13439 readonly x: number;
13440 readonly y: number;
13441 clickEventPrevented(): boolean;
13442 getModifierState(keyArg: string): boolean;
13443 initMouseEvent(typeArg: string, canBubbleArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number, screenXArg?: number, screenYArg?: number, clientXArg?: number, clientYArg?: number, ctrlKeyArg?: boolean, altKeyArg?: boolean, shiftKeyArg?: boolean, metaKeyArg?: boolean, buttonArg?: number, relatedTargetArg?: EventTarget | null): void;
13444 initNSMouseEvent(typeArg: string, canBubbleArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number, screenXArg?: number, screenYArg?: number, clientXArg?: number, clientYArg?: number, ctrlKeyArg?: boolean, altKeyArg?: boolean, shiftKeyArg?: boolean, metaKeyArg?: boolean, buttonArg?: number, relatedTargetArg?: EventTarget | null, pressure?: number, inputSourceArg?: number): void;
13445 preventClickEvent(): void;
13446 readonly MOZ_SOURCE_UNKNOWN: 0;
13447 readonly MOZ_SOURCE_MOUSE: 1;
13448 readonly MOZ_SOURCE_PEN: 2;
13449 readonly MOZ_SOURCE_ERASER: 3;
13450 readonly MOZ_SOURCE_CURSOR: 4;
13451 readonly MOZ_SOURCE_TOUCH: 5;
13452 readonly MOZ_SOURCE_KEYBOARD: 6;
13455 declare var MouseEvent: {
13456 prototype: MouseEvent;
13457 new(typeArg: string, mouseEventInitDict?: MouseEventInit): MouseEvent;
13458 readonly MOZ_SOURCE_UNKNOWN: 0;
13459 readonly MOZ_SOURCE_MOUSE: 1;
13460 readonly MOZ_SOURCE_PEN: 2;
13461 readonly MOZ_SOURCE_ERASER: 3;
13462 readonly MOZ_SOURCE_CURSOR: 4;
13463 readonly MOZ_SOURCE_TOUCH: 5;
13464 readonly MOZ_SOURCE_KEYBOARD: 6;
13465 isInstance: IsInstance<MouseEvent>;
13468 interface MouseScrollEvent extends MouseEvent {
13469 readonly axis: number;
13470 initMouseScrollEvent(type: string, canBubble?: boolean, cancelable?: boolean, view?: Window | null, detail?: number, screenX?: number, screenY?: number, clientX?: number, clientY?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean, button?: number, relatedTarget?: EventTarget | null, axis?: number): void;
13471 readonly HORIZONTAL_AXIS: 1;
13472 readonly VERTICAL_AXIS: 2;
13475 declare var MouseScrollEvent: {
13476 prototype: MouseScrollEvent;
13477 new(): MouseScrollEvent;
13478 readonly HORIZONTAL_AXIS: 1;
13479 readonly VERTICAL_AXIS: 2;
13480 isInstance: IsInstance<MouseScrollEvent>;
13483 interface MozApplicationEvent extends Event {
13484 readonly application: DOMApplication | null;
13487 declare var MozApplicationEvent: {
13488 prototype: MozApplicationEvent;
13489 new(type: string, eventInitDict?: MozApplicationEventInit): MozApplicationEvent;
13490 isInstance: IsInstance<MozApplicationEvent>;
13493 interface MozCanvasPrintState {
13494 readonly context: nsISupports;
13498 declare var MozCanvasPrintState: {
13499 prototype: MozCanvasPrintState;
13500 new(): MozCanvasPrintState;
13501 isInstance: IsInstance<MozCanvasPrintState>;
13504 interface MozChannel {
13507 interface MozDocumentMatcher {
13508 readonly allFrames: boolean;
13509 readonly checkPermissions: boolean;
13510 readonly excludeMatches: MatchPatternSet | null;
13511 readonly extension: WebExtensionPolicy | null;
13512 readonly frameID: number | null;
13513 readonly matchAboutBlank: boolean;
13514 readonly matchOriginAsFallback: boolean;
13515 readonly matches: MatchPatternSet;
13516 readonly originAttributesPatterns: any;
13517 matchesURI(uri: URI): boolean;
13518 matchesWindowGlobal(windowGlobal: WindowGlobalChild, ignorePermissions?: boolean): boolean;
13521 declare var MozDocumentMatcher: {
13522 prototype: MozDocumentMatcher;
13523 new(options: MozDocumentMatcherInit): MozDocumentMatcher;
13524 isInstance: IsInstance<MozDocumentMatcher>;
13527 interface MozDocumentObserver {
13528 disconnect(): void;
13529 observe(matchers: MozDocumentMatcher[]): void;
13532 declare var MozDocumentObserver: {
13533 prototype: MozDocumentObserver;
13534 new(callbacks: MozDocumentCallback): MozDocumentObserver;
13535 isInstance: IsInstance<MozDocumentObserver>;
13538 interface MozEditableElement {
13539 readonly editor: nsIEditor | null;
13540 readonly hasEditor: boolean;
13541 readonly isInputEventTarget: boolean;
13542 setUserInput(input: string): void;
13545 interface MozFrameLoaderOwner {
13546 readonly browsingContext: BrowsingContext | null;
13547 readonly frameLoader: FrameLoader | null;
13548 changeRemoteness(aOptions: RemotenessOptions): void;
13549 swapFrameLoaders(aOtherLoaderOwner: XULFrameElement): void;
13550 swapFrameLoaders(aOtherLoaderOwner: HTMLIFrameElement): void;
13553 interface MozImageLoadingContent {
13554 readonly currentRequestFinalURI: URI | null;
13555 readonly currentURI: URI | null;
13556 loadingEnabled: boolean;
13557 addObserver(aObserver: imgINotificationObserver): void;
13558 forceReload(aNotify?: boolean): void;
13559 getRequest(aRequestType: number): imgIRequest | null;
13560 getRequestType(aRequest: imgIRequest): number;
13561 removeObserver(aObserver: imgINotificationObserver): void;
13562 readonly UNKNOWN_REQUEST: -1;
13563 readonly CURRENT_REQUEST: 0;
13564 readonly PENDING_REQUEST: 1;
13567 interface MozObjectLoadingContent {
13568 readonly actualType: string;
13569 readonly displayedType: number;
13570 readonly srcURI: URI | null;
13571 readonly TYPE_LOADING: 0;
13572 readonly TYPE_DOCUMENT: 1;
13573 readonly TYPE_FALLBACK: 2;
13576 interface MozObserver {
13579 interface MozQueryInterface {
13582 declare var MozQueryInterface: {
13583 prototype: MozQueryInterface;
13584 new(): MozQueryInterface;
13585 isInstance: IsInstance<MozQueryInterface>;
13588 interface MozSharedMap extends EventTarget {
13589 get(name: string): StructuredClonable;
13590 has(name: string): boolean;
13591 forEach(callbackfn: (value: StructuredClonable, key: string, parent: MozSharedMap) => void, thisArg?: any): void;
13594 declare var MozSharedMap: {
13595 prototype: MozSharedMap;
13596 new(): MozSharedMap;
13597 isInstance: IsInstance<MozSharedMap>;
13600 interface MozSharedMapChangeEvent extends Event {
13601 readonly changedKeys: string[];
13604 declare var MozSharedMapChangeEvent: {
13605 prototype: MozSharedMapChangeEvent;
13606 new(): MozSharedMapChangeEvent;
13607 isInstance: IsInstance<MozSharedMapChangeEvent>;
13610 interface MozStorageAsyncStatementParams {
13611 readonly length: number;
13612 [index: number]: any;
13613 [name: string]: any;
13616 declare var MozStorageAsyncStatementParams: {
13617 prototype: MozStorageAsyncStatementParams;
13618 new(): MozStorageAsyncStatementParams;
13619 isInstance: IsInstance<MozStorageAsyncStatementParams>;
13622 interface MozStorageStatementParams {
13623 readonly length: number;
13624 [index: number]: any;
13625 [name: string]: any;
13628 declare var MozStorageStatementParams: {
13629 prototype: MozStorageStatementParams;
13630 new(): MozStorageStatementParams;
13631 isInstance: IsInstance<MozStorageStatementParams>;
13634 interface MozStorageStatementRow {
13635 [name: string]: any;
13638 declare var MozStorageStatementRow: {
13639 prototype: MozStorageStatementRow;
13640 new(): MozStorageStatementRow;
13641 isInstance: IsInstance<MozStorageStatementRow>;
13644 interface MozTreeView {
13647 interface MozWritableSharedMap extends MozSharedMap {
13648 delete(name: string): void;
13650 set(name: string, value: StructuredClonable): void;
13653 declare var MozWritableSharedMap: {
13654 prototype: MozWritableSharedMap;
13655 new(): MozWritableSharedMap;
13656 isInstance: IsInstance<MozWritableSharedMap>;
13659 interface MutationEvent extends Event {
13660 readonly attrChange: number;
13661 readonly attrName: string;
13662 readonly newValue: string;
13663 readonly prevValue: string;
13664 readonly relatedNode: Node | null;
13665 initMutationEvent(type: string, canBubble?: boolean, cancelable?: boolean, relatedNode?: Node | null, prevValue?: string, newValue?: string, attrName?: string, attrChange?: number): void;
13666 readonly MODIFICATION: 1;
13667 readonly ADDITION: 2;
13668 readonly REMOVAL: 3;
13671 declare var MutationEvent: {
13672 prototype: MutationEvent;
13673 new(): MutationEvent;
13674 readonly MODIFICATION: 1;
13675 readonly ADDITION: 2;
13676 readonly REMOVAL: 3;
13677 isInstance: IsInstance<MutationEvent>;
13680 interface MutationObserver {
13681 mergeAttributeRecords: boolean;
13682 readonly mutationCallback: MutationCallback;
13683 disconnect(): void;
13684 getObservingInfo(): (MutationObservingInfo | null)[];
13685 observe(target: Node, options?: MutationObserverInit): void;
13686 takeRecords(): MutationRecord[];
13689 declare var MutationObserver: {
13690 prototype: MutationObserver;
13691 new(mutationCallback: MutationCallback): MutationObserver;
13692 isInstance: IsInstance<MutationObserver>;
13695 interface MutationRecord {
13696 readonly addedAnimations: Animation[];
13697 readonly addedNodes: NodeList;
13698 readonly attributeName: string | null;
13699 readonly attributeNamespace: string | null;
13700 readonly changedAnimations: Animation[];
13701 readonly nextSibling: Node | null;
13702 readonly oldValue: string | null;
13703 readonly previousSibling: Node | null;
13704 readonly removedAnimations: Animation[];
13705 readonly removedNodes: NodeList;
13706 readonly target: Node | null;
13707 readonly type: string;
13710 declare var MutationRecord: {
13711 prototype: MutationRecord;
13712 new(): MutationRecord;
13713 isInstance: IsInstance<MutationRecord>;
13716 interface NamedNodeMap {
13717 readonly length: number;
13718 getNamedItem(name: string): Attr | null;
13719 getNamedItemNS(namespaceURI: string | null, localName: string): Attr | null;
13720 item(index: number): Attr | null;
13721 removeNamedItem(name: string): Attr;
13722 removeNamedItemNS(namespaceURI: string | null, localName: string): Attr;
13723 setNamedItem(arg: Attr): Attr | null;
13724 setNamedItemNS(arg: Attr): Attr | null;
13725 [index: number]: Attr;
13728 declare var NamedNodeMap: {
13729 prototype: NamedNodeMap;
13730 new(): NamedNodeMap;
13731 isInstance: IsInstance<NamedNodeMap>;
13734 /** Available only in secure contexts. */
13735 interface NavigationPreloadManager {
13736 disable(): Promise<void>;
13737 enable(): Promise<void>;
13738 getState(): Promise<NavigationPreloadState>;
13739 setHeaderValue(value: string): Promise<void>;
13742 declare var NavigationPreloadManager: {
13743 prototype: NavigationPreloadManager;
13744 new(): NavigationPreloadManager;
13745 isInstance: IsInstance<NavigationPreloadManager>;
13748 interface Navigator extends GlobalPrivacyControl, NavigatorAutomationInformation, NavigatorConcurrentHardware, NavigatorContentUtils, NavigatorGPU, NavigatorGeolocation, NavigatorID, NavigatorLanguage, NavigatorLocks, NavigatorOnLine, NavigatorStorage {
13749 /** Available only in secure contexts. */
13750 readonly activeVRDisplays: VRDisplay[];
13751 readonly buildID: string;
13752 /** Available only in secure contexts. */
13753 readonly clipboard: Clipboard;
13754 readonly connection: NetworkInformation;
13755 readonly cookieEnabled: boolean;
13756 /** Available only in secure contexts. */
13757 readonly credentials: CredentialsContainer;
13758 readonly doNotTrack: string;
13759 readonly isWebVRContentDetected: boolean;
13760 readonly isWebVRContentPresenting: boolean;
13761 readonly maxTouchPoints: number;
13762 readonly mediaCapabilities: MediaCapabilities;
13763 readonly mediaDevices: MediaDevices;
13764 readonly mediaSession: MediaSession;
13765 readonly mimeTypes: MimeTypeArray;
13766 readonly mozAddonManager: AddonManager;
13767 readonly mozTCPSocket: LegacyMozTCPSocket;
13768 readonly oscpu: string;
13769 readonly pdfViewerEnabled: boolean;
13770 readonly permissions: Permissions;
13771 readonly plugins: PluginArray;
13772 readonly privateAttribution: PrivateAttribution;
13773 readonly productSub: string;
13774 readonly serviceWorker: ServiceWorkerContainer;
13775 readonly testTrialGatedAttribute: boolean;
13776 readonly userActivation: UserActivation;
13777 readonly vendor: string;
13778 readonly vendorSub: string;
13779 readonly wakeLock: WakeLock;
13780 /** Available only in secure contexts. */
13781 readonly xr: XRSystem;
13782 /** Available only in secure contexts. */
13783 canShare(data?: ShareData): boolean;
13784 getAutoplayPolicy(type: AutoplayPolicyMediaType): AutoplayPolicy;
13785 getAutoplayPolicy(element: HTMLMediaElement): AutoplayPolicy;
13786 getAutoplayPolicy(context: AudioContext): AutoplayPolicy;
13787 getBattery(): Promise<BatteryManager>;
13788 getGamepads(): (Gamepad | null)[];
13789 /** Available only in secure contexts. */
13790 getVRDisplays(): Promise<VRDisplay[]>;
13791 javaEnabled(): boolean;
13792 mozGetUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
13793 requestAllGamepads(): Promise<Gamepad[]>;
13794 requestGamepadServiceTest(): GamepadServiceTest;
13795 requestMIDIAccess(options?: MIDIOptions): Promise<MIDIAccess>;
13796 requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccess>;
13797 requestVRPresentation(display: VRDisplay): void;
13798 requestVRServiceTest(): VRServiceTest;
13799 sendBeacon(url: string, data?: BodyInit | null): boolean;
13800 setVibrationPermission(permitted: boolean, persistent?: boolean): void;
13801 /** Available only in secure contexts. */
13802 share(data?: ShareData): Promise<void>;
13803 vibrate(duration: number): boolean;
13804 vibrate(pattern: number[]): boolean;
13807 declare var Navigator: {
13808 prototype: Navigator;
13810 isInstance: IsInstance<Navigator>;
13813 interface NavigatorAutomationInformation {
13814 readonly webdriver: boolean;
13817 interface NavigatorConcurrentHardware {
13818 readonly hardwareConcurrency: number;
13821 interface NavigatorContentUtils {
13822 checkProtocolHandlerAllowed(scheme: string, handlerURI: URI, documentURI: URI): void;
13823 /** Available only in secure contexts. */
13824 registerProtocolHandler(scheme: string, url: string): void;
13827 interface NavigatorGPU {
13828 /** Available only in secure contexts. */
13832 interface NavigatorGeolocation {
13833 readonly geolocation: Geolocation;
13836 interface NavigatorID {
13837 readonly appCodeName: string;
13838 readonly appName: string;
13839 readonly appVersion: string;
13840 readonly platform: string;
13841 readonly product: string;
13842 readonly userAgent: string;
13843 taintEnabled(): boolean;
13846 interface NavigatorLanguage {
13847 readonly language: string | null;
13848 readonly languages: string[];
13851 /** Available only in secure contexts. */
13852 interface NavigatorLocks {
13853 readonly locks: LockManager;
13856 interface NavigatorOnLine {
13857 readonly onLine: boolean;
13860 /** Available only in secure contexts. */
13861 interface NavigatorStorage {
13862 readonly storage: StorageManager;
13865 interface NetworkInformationEventMap {
13866 "typechange": Event;
13869 interface NetworkInformation extends EventTarget {
13870 ontypechange: ((this: NetworkInformation, ev: Event) => any) | null;
13871 readonly type: ConnectionType;
13872 addEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
13873 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
13874 removeEventListener<K extends keyof NetworkInformationEventMap>(type: K, listener: (this: NetworkInformation, ev: NetworkInformationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
13875 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
13878 declare var NetworkInformation: {
13879 prototype: NetworkInformation;
13880 new(): NetworkInformation;
13881 isInstance: IsInstance<NetworkInformation>;
13884 interface Node extends EventTarget {
13885 readonly accessibleNode: AccessibleNode | null;
13886 readonly baseURI: string | null;
13887 readonly baseURIObject: URI | null;
13888 readonly childNodes: NodeList;
13889 readonly containingShadowRoot: ShadowRoot | null;
13890 readonly firstChild: Node | null;
13891 readonly flattenedTreeParentNode: Node | null;
13892 readonly isConnected: boolean;
13893 readonly isNativeAnonymous: boolean;
13894 readonly lastChild: Node | null;
13895 readonly nextSibling: Node | null;
13896 readonly nodeName: string;
13897 readonly nodePrincipal: Principal;
13898 readonly nodeType: number;
13899 nodeValue: string | null;
13900 readonly ownerDocument: Document | null;
13901 readonly parentElement: Element | null;
13902 readonly parentFlexElement: Element | null;
13903 readonly parentNode: Node | null;
13904 readonly previousSibling: Node | null;
13905 textContent: string | null;
13906 appendChild(node: Node): Node;
13907 cloneNode(deep?: boolean): Node;
13908 compareDocumentPosition(other: Node): number;
13909 contains(other: Node | null): boolean;
13910 generateXPath(): string;
13911 getRootNode(options?: GetRootNodeOptions): Node;
13912 hasChildNodes(): boolean;
13913 insertBefore(node: Node, child: Node | null): Node;
13914 isDefaultNamespace(namespace: string | null): boolean;
13915 isEqualNode(node: Node | null): boolean;
13916 isSameNode(node: Node | null): boolean;
13917 lookupNamespaceURI(prefix: string | null): string | null;
13918 lookupPrefix(namespace: string | null): string | null;
13920 removeChild(child: Node): Node;
13921 replaceChild(node: Node, child: Node): Node;
13922 readonly ELEMENT_NODE: 1;
13923 readonly ATTRIBUTE_NODE: 2;
13924 readonly TEXT_NODE: 3;
13925 readonly CDATA_SECTION_NODE: 4;
13926 readonly ENTITY_REFERENCE_NODE: 5;
13927 readonly ENTITY_NODE: 6;
13928 readonly PROCESSING_INSTRUCTION_NODE: 7;
13929 readonly COMMENT_NODE: 8;
13930 readonly DOCUMENT_NODE: 9;
13931 readonly DOCUMENT_TYPE_NODE: 10;
13932 readonly DOCUMENT_FRAGMENT_NODE: 11;
13933 readonly NOTATION_NODE: 12;
13934 readonly DOCUMENT_POSITION_DISCONNECTED: 0x01;
13935 readonly DOCUMENT_POSITION_PRECEDING: 0x02;
13936 readonly DOCUMENT_POSITION_FOLLOWING: 0x04;
13937 readonly DOCUMENT_POSITION_CONTAINS: 0x08;
13938 readonly DOCUMENT_POSITION_CONTAINED_BY: 0x10;
13939 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 0x20;
13942 declare var Node: {
13945 readonly ELEMENT_NODE: 1;
13946 readonly ATTRIBUTE_NODE: 2;
13947 readonly TEXT_NODE: 3;
13948 readonly CDATA_SECTION_NODE: 4;
13949 readonly ENTITY_REFERENCE_NODE: 5;
13950 readonly ENTITY_NODE: 6;
13951 readonly PROCESSING_INSTRUCTION_NODE: 7;
13952 readonly COMMENT_NODE: 8;
13953 readonly DOCUMENT_NODE: 9;
13954 readonly DOCUMENT_TYPE_NODE: 10;
13955 readonly DOCUMENT_FRAGMENT_NODE: 11;
13956 readonly NOTATION_NODE: 12;
13957 readonly DOCUMENT_POSITION_DISCONNECTED: 0x01;
13958 readonly DOCUMENT_POSITION_PRECEDING: 0x02;
13959 readonly DOCUMENT_POSITION_FOLLOWING: 0x04;
13960 readonly DOCUMENT_POSITION_CONTAINS: 0x08;
13961 readonly DOCUMENT_POSITION_CONTAINED_BY: 0x10;
13962 readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 0x20;
13963 isInstance: IsInstance<Node>;
13966 interface NodeIterator {
13967 readonly filter: NodeFilter | null;
13968 readonly pointerBeforeReferenceNode: boolean;
13969 readonly referenceNode: Node | null;
13970 readonly root: Node;
13971 readonly whatToShow: number;
13973 nextNode(): Node | null;
13974 previousNode(): Node | null;
13977 declare var NodeIterator: {
13978 prototype: NodeIterator;
13979 new(): NodeIterator;
13980 isInstance: IsInstance<NodeIterator>;
13983 interface NodeList {
13984 readonly length: number;
13985 item(index: number): Node | null;
13986 forEach(callbackfn: (value: Node | null, key: number, parent: NodeList) => void, thisArg?: any): void;
13987 [index: number]: Node;
13990 declare var NodeList: {
13991 prototype: NodeList;
13993 isInstance: IsInstance<NodeList>;
13996 interface NonDocumentTypeChildNode {
13997 readonly nextElementSibling: Element | null;
13998 readonly previousElementSibling: Element | null;
14001 interface NonElementParentNode {
14002 getElementById(elementId: string): Element | null;
14005 interface NotificationEventMap {
14012 interface Notification extends EventTarget {
14013 readonly body: string | null;
14014 readonly data: any;
14015 readonly dir: NotificationDirection;
14016 readonly icon: string | null;
14017 readonly lang: string | null;
14018 onclick: ((this: Notification, ev: Event) => any) | null;
14019 onclose: ((this: Notification, ev: Event) => any) | null;
14020 onerror: ((this: Notification, ev: Event) => any) | null;
14021 onshow: ((this: Notification, ev: Event) => any) | null;
14022 readonly requireInteraction: boolean;
14023 readonly silent: boolean;
14024 readonly tag: string | null;
14025 readonly title: string;
14026 readonly vibrate: number[];
14028 addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14029 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14030 removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14031 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14034 declare var Notification: {
14035 prototype: Notification;
14036 new(title: string, options?: NotificationOptions): Notification;
14037 isInstance: IsInstance<Notification>;
14038 readonly permission: NotificationPermission;
14039 requestPermission(permissionCallback?: NotificationPermissionCallback): Promise<NotificationPermission>;
14042 interface NotifyPaintEvent extends Event {
14043 readonly boundingClientRect: DOMRect;
14044 readonly clientRects: DOMRectList;
14045 readonly paintRequests: PaintRequestList;
14046 readonly paintTimeStamp: DOMHighResTimeStamp;
14047 readonly transactionId: number;
14050 declare var NotifyPaintEvent: {
14051 prototype: NotifyPaintEvent;
14052 new(): NotifyPaintEvent;
14053 isInstance: IsInstance<NotifyPaintEvent>;
14056 interface OES_draw_buffers_indexed {
14057 blendEquationSeparateiOES(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum): void;
14058 blendEquationiOES(buf: GLuint, mode: GLenum): void;
14059 blendFuncSeparateiOES(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
14060 blendFunciOES(buf: GLuint, src: GLenum, dst: GLenum): void;
14061 colorMaskiOES(buf: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean): void;
14062 disableiOES(target: GLenum, index: GLuint): void;
14063 enableiOES(target: GLenum, index: GLuint): void;
14066 interface OES_element_index_uint {
14069 interface OES_fbo_render_mipmap {
14072 interface OES_standard_derivatives {
14073 readonly FRAGMENT_SHADER_DERIVATIVE_HINT_OES: 0x8B8B;
14076 interface OES_texture_float {
14079 interface OES_texture_float_linear {
14082 interface OES_texture_half_float {
14083 readonly HALF_FLOAT_OES: 0x8D61;
14086 interface OES_texture_half_float_linear {
14089 interface OES_vertex_array_object {
14090 bindVertexArrayOES(arrayObject: WebGLVertexArrayObject | null): void;
14091 createVertexArrayOES(): WebGLVertexArrayObject | null;
14092 deleteVertexArrayOES(arrayObject: WebGLVertexArrayObject | null): void;
14093 isVertexArrayOES(arrayObject: WebGLVertexArrayObject | null): GLboolean;
14094 readonly VERTEX_ARRAY_BINDING_OES: 0x85B5;
14097 interface OVR_multiview2 {
14098 framebufferTextureMultiviewOVR(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, baseViewIndex: GLint, numViews: GLsizei): void;
14099 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR: 0x9630;
14100 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR: 0x9632;
14101 readonly MAX_VIEWS_OVR: 0x9631;
14102 readonly FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR: 0x9633;
14105 interface OfflineAudioCompletionEvent extends Event {
14106 readonly renderedBuffer: AudioBuffer;
14109 declare var OfflineAudioCompletionEvent: {
14110 prototype: OfflineAudioCompletionEvent;
14111 new(type: string, eventInitDict: OfflineAudioCompletionEventInit): OfflineAudioCompletionEvent;
14112 isInstance: IsInstance<OfflineAudioCompletionEvent>;
14115 interface OfflineAudioContextEventMap extends BaseAudioContextEventMap {
14119 interface OfflineAudioContext extends BaseAudioContext {
14120 readonly length: number;
14121 oncomplete: ((this: OfflineAudioContext, ev: Event) => any) | null;
14122 startRendering(): Promise<AudioBuffer>;
14123 addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14124 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14125 removeEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14126 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14129 declare var OfflineAudioContext: {
14130 prototype: OfflineAudioContext;
14131 new(contextOptions: OfflineAudioContextOptions): OfflineAudioContext;
14132 new(numberOfChannels: number, length: number, sampleRate: number): OfflineAudioContext;
14133 isInstance: IsInstance<OfflineAudioContext>;
14136 interface OffscreenCanvasEventMap {
14137 "contextlost": Event;
14138 "contextrestored": Event;
14141 interface OffscreenCanvas extends EventTarget {
14143 oncontextlost: ((this: OffscreenCanvas, ev: Event) => any) | null;
14144 oncontextrestored: ((this: OffscreenCanvas, ev: Event) => any) | null;
14146 convertToBlob(options?: ImageEncodeOptions): Promise<Blob>;
14147 getContext(contextId: OffscreenRenderingContextId, contextOptions?: any): OffscreenRenderingContext | null;
14148 toBlob(type?: string, encoderOptions?: any): Promise<Blob>;
14149 transferToImageBitmap(): ImageBitmap;
14150 addEventListener<K extends keyof OffscreenCanvasEventMap>(type: K, listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14151 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14152 removeEventListener<K extends keyof OffscreenCanvasEventMap>(type: K, listener: (this: OffscreenCanvas, ev: OffscreenCanvasEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14153 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14156 declare var OffscreenCanvas: {
14157 prototype: OffscreenCanvas;
14158 new(width: number, height: number): OffscreenCanvas;
14159 isInstance: IsInstance<OffscreenCanvas>;
14162 interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPathDrawingStyles, CanvasPathMethods, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform {
14163 readonly canvas: OffscreenCanvas;
14167 declare var OffscreenCanvasRenderingContext2D: {
14168 prototype: OffscreenCanvasRenderingContext2D;
14169 new(): OffscreenCanvasRenderingContext2D;
14170 isInstance: IsInstance<OffscreenCanvasRenderingContext2D>;
14173 interface OnErrorEventHandlerForNodesEventMap {
14177 interface OnErrorEventHandlerForNodes {
14178 onerror: ((this: OnErrorEventHandlerForNodes, ev: Event) => any) | null;
14179 addEventListener<K extends keyof OnErrorEventHandlerForNodesEventMap>(type: K, listener: (this: OnErrorEventHandlerForNodes, ev: OnErrorEventHandlerForNodesEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14180 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14181 removeEventListener<K extends keyof OnErrorEventHandlerForNodesEventMap>(type: K, listener: (this: OnErrorEventHandlerForNodes, ev: OnErrorEventHandlerForNodesEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14182 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14185 interface OnErrorEventHandlerForWindowEventMap {
14189 interface OnErrorEventHandlerForWindow {
14190 onerror: ((this: OnErrorEventHandlerForWindow, ev: Event) => any) | null;
14191 addEventListener<K extends keyof OnErrorEventHandlerForWindowEventMap>(type: K, listener: (this: OnErrorEventHandlerForWindow, ev: OnErrorEventHandlerForWindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14192 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14193 removeEventListener<K extends keyof OnErrorEventHandlerForWindowEventMap>(type: K, listener: (this: OnErrorEventHandlerForWindow, ev: OnErrorEventHandlerForWindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14194 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14197 interface OscillatorNode extends AudioScheduledSourceNode, AudioNodePassThrough {
14198 readonly detune: AudioParam;
14199 readonly frequency: AudioParam;
14200 type: OscillatorType;
14201 setPeriodicWave(periodicWave: PeriodicWave): void;
14202 addEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14203 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14204 removeEventListener<K extends keyof AudioScheduledSourceNodeEventMap>(type: K, listener: (this: OscillatorNode, ev: AudioScheduledSourceNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14205 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14208 declare var OscillatorNode: {
14209 prototype: OscillatorNode;
14210 new(context: BaseAudioContext, options?: OscillatorOptions): OscillatorNode;
14211 isInstance: IsInstance<OscillatorNode>;
14214 interface OutputStream {
14217 interface PageTransitionEvent extends Event {
14218 readonly inFrameSwap: boolean;
14219 readonly persisted: boolean;
14222 declare var PageTransitionEvent: {
14223 prototype: PageTransitionEvent;
14224 new(type: string, eventInitDict?: PageTransitionEventInit): PageTransitionEvent;
14225 isInstance: IsInstance<PageTransitionEvent>;
14228 interface PaintRequest {
14229 readonly clientRect: DOMRect;
14230 readonly reason: string;
14233 declare var PaintRequest: {
14234 prototype: PaintRequest;
14235 new(): PaintRequest;
14236 isInstance: IsInstance<PaintRequest>;
14239 interface PaintRequestList {
14240 readonly length: number;
14241 item(index: number): PaintRequest | null;
14242 [index: number]: PaintRequest;
14245 declare var PaintRequestList: {
14246 prototype: PaintRequestList;
14247 new(): PaintRequestList;
14248 isInstance: IsInstance<PaintRequestList>;
14251 interface PannerNode extends AudioNode, AudioNodePassThrough {
14252 coneInnerAngle: number;
14253 coneOuterAngle: number;
14254 coneOuterGain: number;
14255 distanceModel: DistanceModelType;
14256 maxDistance: number;
14257 readonly orientationX: AudioParam;
14258 readonly orientationY: AudioParam;
14259 readonly orientationZ: AudioParam;
14260 panningModel: PanningModelType;
14261 readonly positionX: AudioParam;
14262 readonly positionY: AudioParam;
14263 readonly positionZ: AudioParam;
14264 refDistance: number;
14265 rolloffFactor: number;
14266 setOrientation(x: number, y: number, z: number): void;
14267 setPosition(x: number, y: number, z: number): void;
14270 declare var PannerNode: {
14271 prototype: PannerNode;
14272 new(context: BaseAudioContext, options?: PannerOptions): PannerNode;
14273 isInstance: IsInstance<PannerNode>;
14276 interface ParentNode {
14277 readonly childElementCount: number;
14278 readonly children: HTMLCollection;
14279 readonly firstElementChild: Element | null;
14280 readonly lastElementChild: Element | null;
14281 append(...nodes: (Node | string)[]): void;
14282 getElementsByAttribute(name: string, value: string | null): HTMLCollection;
14283 getElementsByAttributeNS(namespaceURI: string | null, name: string, value: string | null): HTMLCollection;
14284 prepend(...nodes: (Node | string)[]): void;
14285 querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
14286 querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
14287 querySelector<K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
14289 querySelector<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
14290 querySelector<E extends Element = Element>(selectors: string): E | null;
14291 querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
14292 querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
14293 querySelectorAll<K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
14295 querySelectorAll<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
14296 querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
14297 replaceChildren(...nodes: (Node | string)[]): void;
14300 interface ParentProcessMessageManager extends MessageBroadcaster, GlobalProcessScriptLoader, ProcessScriptLoader {
14303 declare var ParentProcessMessageManager: {
14304 prototype: ParentProcessMessageManager;
14305 new(): ParentProcessMessageManager;
14306 isInstance: IsInstance<ParentProcessMessageManager>;
14309 interface Path2D extends CanvasPathMethods {
14310 addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
14313 declare var Path2D: {
14316 new(other: Path2D): Path2D;
14317 new(pathString: string): Path2D;
14318 isInstance: IsInstance<Path2D>;
14321 /** Available only in secure contexts. */
14322 interface PaymentAddress {
14323 readonly addressLine: string[];
14324 readonly city: string;
14325 readonly country: string;
14326 readonly dependentLocality: string;
14327 readonly organization: string;
14328 readonly phone: string;
14329 readonly postalCode: string;
14330 readonly recipient: string;
14331 readonly region: string;
14332 readonly regionCode: string;
14333 readonly sortingCode: string;
14337 declare var PaymentAddress: {
14338 prototype: PaymentAddress;
14339 new(): PaymentAddress;
14340 isInstance: IsInstance<PaymentAddress>;
14343 /** Available only in secure contexts. */
14344 interface PaymentMethodChangeEvent extends PaymentRequestUpdateEvent {
14345 readonly methodDetails: any;
14346 readonly methodName: string;
14349 declare var PaymentMethodChangeEvent: {
14350 prototype: PaymentMethodChangeEvent;
14351 new(type: string, eventInitDict?: PaymentMethodChangeEventInit): PaymentMethodChangeEvent;
14352 isInstance: IsInstance<PaymentMethodChangeEvent>;
14355 interface PaymentRequestEventMap {
14356 "merchantvalidation": Event;
14357 "paymentmethodchange": Event;
14358 "shippingaddresschange": Event;
14359 "shippingoptionchange": Event;
14362 /** Available only in secure contexts. */
14363 interface PaymentRequest extends EventTarget {
14364 readonly id: string;
14365 onmerchantvalidation: ((this: PaymentRequest, ev: Event) => any) | null;
14366 onpaymentmethodchange: ((this: PaymentRequest, ev: Event) => any) | null;
14367 onshippingaddresschange: ((this: PaymentRequest, ev: Event) => any) | null;
14368 onshippingoptionchange: ((this: PaymentRequest, ev: Event) => any) | null;
14369 readonly shippingAddress: PaymentAddress | null;
14370 readonly shippingOption: string | null;
14371 readonly shippingType: PaymentShippingType | null;
14372 abort(): Promise<void>;
14373 canMakePayment(): Promise<boolean>;
14374 show(detailsPromise?: PaymentDetailsUpdate | PromiseLike<PaymentDetailsUpdate>): Promise<PaymentResponse>;
14375 addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14376 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14377 removeEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14378 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14381 declare var PaymentRequest: {
14382 prototype: PaymentRequest;
14383 new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest;
14384 isInstance: IsInstance<PaymentRequest>;
14387 /** Available only in secure contexts. */
14388 interface PaymentRequestUpdateEvent extends Event {
14389 updateWith(detailsPromise: PaymentDetailsUpdate | PromiseLike<PaymentDetailsUpdate>): void;
14392 declare var PaymentRequestUpdateEvent: {
14393 prototype: PaymentRequestUpdateEvent;
14394 new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent;
14395 isInstance: IsInstance<PaymentRequestUpdateEvent>;
14398 interface PaymentResponseEventMap {
14399 "payerdetailchange": Event;
14402 /** Available only in secure contexts. */
14403 interface PaymentResponse extends EventTarget {
14404 readonly details: any;
14405 readonly methodName: string;
14406 onpayerdetailchange: ((this: PaymentResponse, ev: Event) => any) | null;
14407 readonly payerEmail: string | null;
14408 readonly payerName: string | null;
14409 readonly payerPhone: string | null;
14410 readonly requestId: string;
14411 readonly shippingAddress: PaymentAddress | null;
14412 readonly shippingOption: string | null;
14413 complete(result?: PaymentComplete): Promise<void>;
14414 retry(errorFields?: PaymentValidationErrors): Promise<void>;
14416 addEventListener<K extends keyof PaymentResponseEventMap>(type: K, listener: (this: PaymentResponse, ev: PaymentResponseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14417 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14418 removeEventListener<K extends keyof PaymentResponseEventMap>(type: K, listener: (this: PaymentResponse, ev: PaymentResponseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14419 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14422 declare var PaymentResponse: {
14423 prototype: PaymentResponse;
14424 new(): PaymentResponse;
14425 isInstance: IsInstance<PaymentResponse>;
14428 interface PeerConnectionImpl {
14429 certificate: RTCCertificate;
14430 readonly connectionState: RTCPeerConnectionState;
14431 readonly currentLocalDescription: string;
14432 readonly currentOfferer: boolean | null;
14433 readonly currentRemoteDescription: string;
14434 readonly fingerprint: string;
14435 readonly iceConnectionState: RTCIceConnectionState;
14436 readonly iceGatheringState: RTCIceGatheringState;
14438 peerIdentity: string;
14439 readonly pendingLocalDescription: string;
14440 readonly pendingOfferer: boolean | null;
14441 readonly pendingRemoteDescription: string;
14442 readonly privacyRequested: boolean;
14443 readonly sctp: RTCSctpTransport | null;
14444 readonly signalingState: RTCSignalingState;
14445 addIceCandidate(candidate: string, mid: string, ufrag: string, level: number | null): void;
14446 addTransceiver(init: RTCRtpTransceiverInit, kind: string, sendTrack: MediaStreamTrack | null, addTrackMagic: boolean): RTCRtpTransceiver;
14447 chain(op: ChainedOperation): Promise<any>;
14449 closeStreams(): void;
14450 createAnswer(): void;
14451 createDataChannel(label: string, protocol: string, type: number, ordered: boolean, maxTime: number, maxNum: number, externalNegotiated: boolean, stream: number): RTCDataChannel;
14452 createOffer(options?: RTCOfferOptions): void;
14453 createdSender(sender: RTCRtpSender): boolean;
14454 disablePacketDump(level: number, type: mozPacketDumpType, sending: boolean): void;
14455 enablePacketDump(level: number, type: mozPacketDumpType, sending: boolean): void;
14456 getRemoteStreams(): MediaStream[];
14457 getStats(selector: MediaStreamTrack | null): Promise<RTCStatsReport>;
14458 getTransceivers(): RTCRtpTransceiver[];
14459 initialize(observer: PeerConnectionObserver, window: Window): void;
14460 onSetDescriptionError(): void;
14461 onSetDescriptionSuccess(type: RTCSdpType, remote: boolean): Promise<void>;
14462 pluginCrash(pluginId: number, name: string): boolean;
14463 restartIce(): void;
14464 restartIceNoRenegotiationNeeded(): void;
14465 setConfiguration(config?: RTCConfiguration): void;
14466 setLocalDescription(action: number, sdp: string): void;
14467 setRemoteDescription(action: number, sdp: string): void;
14468 updateNegotiationNeeded(): void;
14471 declare var PeerConnectionImpl: {
14472 prototype: PeerConnectionImpl;
14473 new(): PeerConnectionImpl;
14474 isInstance: IsInstance<PeerConnectionImpl>;
14477 interface PeerConnectionObserver {
14478 fireNegotiationNeededEvent(): void;
14479 fireStreamEvent(stream: MediaStream): void;
14480 fireTrackEvent(receiver: RTCRtpReceiver, streams: MediaStream[]): void;
14481 notifyDataChannel(channel: RTCDataChannel): void;
14482 onAddIceCandidateError(error: PCErrorData): void;
14483 onAddIceCandidateSuccess(): void;
14484 onCreateAnswerError(error: PCErrorData): void;
14485 onCreateAnswerSuccess(answer: string): void;
14486 onCreateOfferError(error: PCErrorData): void;
14487 onCreateOfferSuccess(offer: string): void;
14488 onIceCandidate(level: number, mid: string, candidate: string, ufrag: string): void;
14489 onPacket(level: number, type: mozPacketDumpType, sending: boolean, packet: ArrayBuffer): void;
14490 onSetDescriptionError(error: PCErrorData): void;
14491 onSetDescriptionSuccess(): void;
14492 onStateChange(state: PCObserverStateType): void;
14495 declare var PeerConnectionObserver: {
14496 prototype: PeerConnectionObserver;
14497 new(domPC: RTCPeerConnection): PeerConnectionObserver;
14498 isInstance: IsInstance<PeerConnectionObserver>;
14501 interface PerformanceEventMap {
14502 "resourcetimingbufferfull": Event;
14505 interface Performance extends EventTarget {
14506 readonly eventCounts: EventCounts;
14507 readonly mozMemory: any;
14508 readonly navigation: PerformanceNavigation;
14509 onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
14510 readonly timeOrigin: DOMHighResTimeStamp;
14511 readonly timing: PerformanceTiming;
14512 clearMarks(markName?: string): void;
14513 clearMeasures(measureName?: string): void;
14514 clearResourceTimings(): void;
14515 getEntries(): PerformanceEntryList;
14516 getEntriesByName(name: string, entryType?: string): PerformanceEntryList;
14517 getEntriesByType(entryType: string): PerformanceEntryList;
14518 mark(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
14519 measure(measureName: string, startOrMeasureOptions?: string | PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
14520 now(): DOMHighResTimeStamp;
14521 setResourceTimingBufferSize(maxSize: number): void;
14523 addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14524 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14525 removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14526 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14529 declare var Performance: {
14530 prototype: Performance;
14531 new(): Performance;
14532 isInstance: IsInstance<Performance>;
14535 interface PerformanceEntry {
14536 readonly duration: DOMHighResTimeStamp;
14537 readonly entryType: string;
14538 readonly name: string;
14539 readonly startTime: DOMHighResTimeStamp;
14543 declare var PerformanceEntry: {
14544 prototype: PerformanceEntry;
14545 new(): PerformanceEntry;
14546 isInstance: IsInstance<PerformanceEntry>;
14549 interface PerformanceEntryEvent extends Event {
14550 readonly duration: DOMHighResTimeStamp;
14551 readonly entryType: string;
14552 readonly epoch: number;
14553 readonly name: string;
14554 readonly origin: string;
14555 readonly startTime: DOMHighResTimeStamp;
14558 declare var PerformanceEntryEvent: {
14559 prototype: PerformanceEntryEvent;
14560 new(type: string, eventInitDict?: PerformanceEntryEventInit): PerformanceEntryEvent;
14561 isInstance: IsInstance<PerformanceEntryEvent>;
14564 interface PerformanceEventTiming extends PerformanceEntry {
14565 readonly cancelable: boolean;
14566 readonly processingEnd: DOMHighResTimeStamp;
14567 readonly processingStart: DOMHighResTimeStamp;
14568 readonly target: Node | null;
14572 declare var PerformanceEventTiming: {
14573 prototype: PerformanceEventTiming;
14574 new(): PerformanceEventTiming;
14575 isInstance: IsInstance<PerformanceEventTiming>;
14578 interface PerformanceMark extends PerformanceEntry {
14579 readonly detail: any;
14582 declare var PerformanceMark: {
14583 prototype: PerformanceMark;
14584 new(markName: string, markOptions?: PerformanceMarkOptions): PerformanceMark;
14585 isInstance: IsInstance<PerformanceMark>;
14588 interface PerformanceMeasure extends PerformanceEntry {
14589 readonly detail: any;
14592 declare var PerformanceMeasure: {
14593 prototype: PerformanceMeasure;
14594 new(): PerformanceMeasure;
14595 isInstance: IsInstance<PerformanceMeasure>;
14598 interface PerformanceNavigation {
14599 readonly redirectCount: number;
14600 readonly type: number;
14602 readonly TYPE_NAVIGATE: 0;
14603 readonly TYPE_RELOAD: 1;
14604 readonly TYPE_BACK_FORWARD: 2;
14605 readonly TYPE_RESERVED: 255;
14608 declare var PerformanceNavigation: {
14609 prototype: PerformanceNavigation;
14610 new(): PerformanceNavigation;
14611 readonly TYPE_NAVIGATE: 0;
14612 readonly TYPE_RELOAD: 1;
14613 readonly TYPE_BACK_FORWARD: 2;
14614 readonly TYPE_RESERVED: 255;
14615 isInstance: IsInstance<PerformanceNavigation>;
14618 interface PerformanceNavigationTiming extends PerformanceResourceTiming {
14619 readonly domComplete: DOMHighResTimeStamp;
14620 readonly domContentLoadedEventEnd: DOMHighResTimeStamp;
14621 readonly domContentLoadedEventStart: DOMHighResTimeStamp;
14622 readonly domInteractive: DOMHighResTimeStamp;
14623 readonly loadEventEnd: DOMHighResTimeStamp;
14624 readonly loadEventStart: DOMHighResTimeStamp;
14625 readonly redirectCount: number;
14626 readonly type: NavigationType;
14627 readonly unloadEventEnd: DOMHighResTimeStamp;
14628 readonly unloadEventStart: DOMHighResTimeStamp;
14632 declare var PerformanceNavigationTiming: {
14633 prototype: PerformanceNavigationTiming;
14634 new(): PerformanceNavigationTiming;
14635 isInstance: IsInstance<PerformanceNavigationTiming>;
14638 interface PerformanceObserver {
14639 disconnect(): void;
14640 observe(options?: PerformanceObserverInit): void;
14641 takeRecords(): PerformanceEntryList;
14644 declare var PerformanceObserver: {
14645 prototype: PerformanceObserver;
14646 new(callback: PerformanceObserverCallback): PerformanceObserver;
14647 isInstance: IsInstance<PerformanceObserver>;
14648 readonly supportedEntryTypes: any;
14651 interface PerformanceObserverEntryList {
14652 getEntries(filter?: PerformanceEntryFilterOptions): PerformanceEntryList;
14653 getEntriesByName(name: string, entryType?: string): PerformanceEntryList;
14654 getEntriesByType(entryType: string): PerformanceEntryList;
14657 declare var PerformanceObserverEntryList: {
14658 prototype: PerformanceObserverEntryList;
14659 new(): PerformanceObserverEntryList;
14660 isInstance: IsInstance<PerformanceObserverEntryList>;
14663 interface PerformancePaintTiming extends PerformanceEntry {
14666 declare var PerformancePaintTiming: {
14667 prototype: PerformancePaintTiming;
14668 new(): PerformancePaintTiming;
14669 isInstance: IsInstance<PerformancePaintTiming>;
14672 interface PerformanceResourceTiming extends PerformanceEntry {
14673 readonly connectEnd: DOMHighResTimeStamp;
14674 readonly connectStart: DOMHighResTimeStamp;
14675 readonly decodedBodySize: number;
14676 readonly domainLookupEnd: DOMHighResTimeStamp;
14677 readonly domainLookupStart: DOMHighResTimeStamp;
14678 readonly encodedBodySize: number;
14679 readonly fetchStart: DOMHighResTimeStamp;
14680 readonly initiatorType: string;
14681 readonly nextHopProtocol: string;
14682 readonly redirectEnd: DOMHighResTimeStamp;
14683 readonly redirectStart: DOMHighResTimeStamp;
14684 readonly renderBlockingStatus: RenderBlockingStatusType;
14685 readonly requestStart: DOMHighResTimeStamp;
14686 readonly responseEnd: DOMHighResTimeStamp;
14687 readonly responseStart: DOMHighResTimeStamp;
14688 readonly secureConnectionStart: DOMHighResTimeStamp;
14689 /** Available only in secure contexts. */
14690 readonly serverTiming: PerformanceServerTiming[];
14691 readonly transferSize: number;
14692 readonly workerStart: DOMHighResTimeStamp;
14696 declare var PerformanceResourceTiming: {
14697 prototype: PerformanceResourceTiming;
14698 new(): PerformanceResourceTiming;
14699 isInstance: IsInstance<PerformanceResourceTiming>;
14702 /** Available only in secure contexts. */
14703 interface PerformanceServerTiming {
14704 readonly description: string;
14705 readonly duration: DOMHighResTimeStamp;
14706 readonly name: string;
14710 declare var PerformanceServerTiming: {
14711 prototype: PerformanceServerTiming;
14712 new(): PerformanceServerTiming;
14713 isInstance: IsInstance<PerformanceServerTiming>;
14716 interface PerformanceTiming {
14717 readonly connectEnd: number;
14718 readonly connectStart: number;
14719 readonly domComplete: number;
14720 readonly domContentLoadedEventEnd: number;
14721 readonly domContentLoadedEventStart: number;
14722 readonly domInteractive: number;
14723 readonly domLoading: number;
14724 readonly domainLookupEnd: number;
14725 readonly domainLookupStart: number;
14726 readonly fetchStart: number;
14727 readonly loadEventEnd: number;
14728 readonly loadEventStart: number;
14729 readonly navigationStart: number;
14730 readonly redirectEnd: number;
14731 readonly redirectStart: number;
14732 readonly requestStart: number;
14733 readonly responseEnd: number;
14734 readonly responseStart: number;
14735 readonly secureConnectionStart: number;
14736 readonly timeToContentfulPaint: number;
14737 readonly timeToDOMContentFlushed: number;
14738 readonly timeToFirstInteractive: number;
14739 readonly timeToNonBlankPaint: number;
14740 readonly unloadEventEnd: number;
14741 readonly unloadEventStart: number;
14745 declare var PerformanceTiming: {
14746 prototype: PerformanceTiming;
14747 new(): PerformanceTiming;
14748 isInstance: IsInstance<PerformanceTiming>;
14751 interface PeriodicWave {
14754 declare var PeriodicWave: {
14755 prototype: PeriodicWave;
14756 new(context: BaseAudioContext, options?: PeriodicWaveOptions): PeriodicWave;
14757 isInstance: IsInstance<PeriodicWave>;
14760 interface PermissionStatusEventMap {
14764 interface PermissionStatus extends EventTarget {
14765 readonly name: PermissionName;
14766 onchange: ((this: PermissionStatus, ev: Event) => any) | null;
14767 readonly state: PermissionState;
14768 readonly type: string;
14769 addEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
14770 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
14771 removeEventListener<K extends keyof PermissionStatusEventMap>(type: K, listener: (this: PermissionStatus, ev: PermissionStatusEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
14772 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
14775 declare var PermissionStatus: {
14776 prototype: PermissionStatus;
14777 new(): PermissionStatus;
14778 isInstance: IsInstance<PermissionStatus>;
14781 interface Permissions {
14782 parseSetParameters(parameters: PermissionSetParameters): PermissionStatus;
14783 query(permission: any): Promise<PermissionStatus>;
14786 declare var Permissions: {
14787 prototype: Permissions;
14788 new(): Permissions;
14789 isInstance: IsInstance<Permissions>;
14792 interface PlacesBookmark extends PlacesEvent {
14793 readonly guid: string;
14794 readonly id: number;
14795 readonly isTagging: boolean;
14796 readonly itemType: number;
14797 readonly parentGuid: string;
14798 readonly parentId: number;
14799 readonly source: number;
14800 readonly url: string;
14803 declare var PlacesBookmark: {
14804 prototype: PlacesBookmark;
14805 new(): PlacesBookmark;
14806 isInstance: IsInstance<PlacesBookmark>;
14809 interface PlacesBookmarkAddition extends PlacesBookmark {
14810 readonly dateAdded: number;
14811 readonly frecency: number;
14812 readonly hidden: boolean;
14813 readonly index: number;
14814 readonly lastVisitDate: number | null;
14815 readonly tags: string;
14816 readonly targetFolderGuid: string;
14817 readonly targetFolderItemId: number;
14818 readonly targetFolderTitle: string;
14819 readonly title: string;
14820 readonly visitCount: number;
14823 declare var PlacesBookmarkAddition: {
14824 prototype: PlacesBookmarkAddition;
14825 new(initDict: PlacesBookmarkAdditionInit): PlacesBookmarkAddition;
14826 isInstance: IsInstance<PlacesBookmarkAddition>;
14829 interface PlacesBookmarkChanged extends PlacesBookmark {
14830 readonly lastModified: number;
14833 declare var PlacesBookmarkChanged: {
14834 prototype: PlacesBookmarkChanged;
14835 new(): PlacesBookmarkChanged;
14836 isInstance: IsInstance<PlacesBookmarkChanged>;
14839 interface PlacesBookmarkGuid extends PlacesBookmarkChanged {
14842 declare var PlacesBookmarkGuid: {
14843 prototype: PlacesBookmarkGuid;
14844 new(initDict: PlacesBookmarkGuidInit): PlacesBookmarkGuid;
14845 isInstance: IsInstance<PlacesBookmarkGuid>;
14848 interface PlacesBookmarkKeyword extends PlacesBookmarkChanged {
14849 readonly keyword: string;
14852 declare var PlacesBookmarkKeyword: {
14853 prototype: PlacesBookmarkKeyword;
14854 new(initDict: PlacesBookmarkKeywordInit): PlacesBookmarkKeyword;
14855 isInstance: IsInstance<PlacesBookmarkKeyword>;
14858 interface PlacesBookmarkMoved extends PlacesBookmark {
14859 readonly dateAdded: number;
14860 readonly frecency: number;
14861 readonly hidden: boolean;
14862 readonly index: number;
14863 readonly lastVisitDate: number | null;
14864 readonly oldIndex: number;
14865 readonly oldParentGuid: string;
14866 readonly tags: string;
14867 readonly title: string;
14868 readonly visitCount: number;
14871 declare var PlacesBookmarkMoved: {
14872 prototype: PlacesBookmarkMoved;
14873 new(initDict: PlacesBookmarkMovedInit): PlacesBookmarkMoved;
14874 isInstance: IsInstance<PlacesBookmarkMoved>;
14877 interface PlacesBookmarkRemoved extends PlacesBookmark {
14878 readonly index: number;
14879 readonly isDescendantRemoval: boolean;
14880 readonly title: string;
14883 declare var PlacesBookmarkRemoved: {
14884 prototype: PlacesBookmarkRemoved;
14885 new(initDict: PlacesBookmarkRemovedInit): PlacesBookmarkRemoved;
14886 isInstance: IsInstance<PlacesBookmarkRemoved>;
14889 interface PlacesBookmarkTags extends PlacesBookmarkChanged {
14890 readonly tags: string[];
14893 declare var PlacesBookmarkTags: {
14894 prototype: PlacesBookmarkTags;
14895 new(initDict: PlacesBookmarkTagsInit): PlacesBookmarkTags;
14896 isInstance: IsInstance<PlacesBookmarkTags>;
14899 interface PlacesBookmarkTime extends PlacesBookmarkChanged {
14900 readonly dateAdded: number;
14903 declare var PlacesBookmarkTime: {
14904 prototype: PlacesBookmarkTime;
14905 new(initDict: PlacesBookmarkTimeInit): PlacesBookmarkTime;
14906 isInstance: IsInstance<PlacesBookmarkTime>;
14909 interface PlacesBookmarkTitle extends PlacesBookmarkChanged {
14910 readonly title: string;
14913 declare var PlacesBookmarkTitle: {
14914 prototype: PlacesBookmarkTitle;
14915 new(initDict: PlacesBookmarkTitleInit): PlacesBookmarkTitle;
14916 isInstance: IsInstance<PlacesBookmarkTitle>;
14919 interface PlacesBookmarkUrl extends PlacesBookmarkChanged {
14922 declare var PlacesBookmarkUrl: {
14923 prototype: PlacesBookmarkUrl;
14924 new(initDict: PlacesBookmarkUrlInit): PlacesBookmarkUrl;
14925 isInstance: IsInstance<PlacesBookmarkUrl>;
14928 interface PlacesEvent {
14929 readonly type: PlacesEventType;
14932 declare var PlacesEvent: {
14933 prototype: PlacesEvent;
14934 new(): PlacesEvent;
14935 isInstance: IsInstance<PlacesEvent>;
14938 interface PlacesEventCounts {
14939 forEach(callbackfn: (value: number, key: string, parent: PlacesEventCounts) => void, thisArg?: any): void;
14942 declare var PlacesEventCounts: {
14943 prototype: PlacesEventCounts;
14944 new(): PlacesEventCounts;
14945 isInstance: IsInstance<PlacesEventCounts>;
14948 interface PlacesFavicon extends PlacesEvent {
14949 readonly faviconUrl: string;
14950 readonly pageGuid: string;
14951 readonly url: string;
14954 declare var PlacesFavicon: {
14955 prototype: PlacesFavicon;
14956 new(initDict: PlacesFaviconInit): PlacesFavicon;
14957 isInstance: IsInstance<PlacesFavicon>;
14960 interface PlacesHistoryCleared extends PlacesEvent {
14963 declare var PlacesHistoryCleared: {
14964 prototype: PlacesHistoryCleared;
14965 new(): PlacesHistoryCleared;
14966 isInstance: IsInstance<PlacesHistoryCleared>;
14969 interface PlacesPurgeCaches extends PlacesEvent {
14972 declare var PlacesPurgeCaches: {
14973 prototype: PlacesPurgeCaches;
14974 new(): PlacesPurgeCaches;
14975 isInstance: IsInstance<PlacesPurgeCaches>;
14978 interface PlacesRanking extends PlacesEvent {
14981 declare var PlacesRanking: {
14982 prototype: PlacesRanking;
14983 new(): PlacesRanking;
14984 isInstance: IsInstance<PlacesRanking>;
14987 interface PlacesVisit extends PlacesEvent {
14988 readonly frecency: number;
14989 readonly hidden: boolean;
14990 readonly lastKnownTitle: string | null;
14991 readonly pageGuid: string;
14992 readonly referringVisitId: number;
14993 readonly transitionType: number;
14994 readonly typedCount: number;
14995 readonly url: string;
14996 readonly visitCount: number;
14997 readonly visitId: number;
14998 readonly visitTime: number;
15001 declare var PlacesVisit: {
15002 prototype: PlacesVisit;
15003 new(): PlacesVisit;
15004 isInstance: IsInstance<PlacesVisit>;
15007 interface PlacesVisitRemoved extends PlacesEvent {
15008 readonly isPartialVisistsRemoval: boolean;
15009 readonly isRemovedFromStore: boolean;
15010 readonly pageGuid: string;
15011 readonly reason: number;
15012 readonly transitionType: number;
15013 readonly url: string;
15014 readonly REASON_DELETED: 0;
15015 readonly REASON_EXPIRED: 1;
15018 declare var PlacesVisitRemoved: {
15019 prototype: PlacesVisitRemoved;
15020 new(initDict: PlacesVisitRemovedInit): PlacesVisitRemoved;
15021 readonly REASON_DELETED: 0;
15022 readonly REASON_EXPIRED: 1;
15023 isInstance: IsInstance<PlacesVisitRemoved>;
15026 interface PlacesVisitTitle extends PlacesEvent {
15027 readonly pageGuid: string;
15028 readonly title: string;
15029 readonly url: string;
15032 declare var PlacesVisitTitle: {
15033 prototype: PlacesVisitTitle;
15034 new(initDict: PlacesVisitTitleInit): PlacesVisitTitle;
15035 isInstance: IsInstance<PlacesVisitTitle>;
15038 interface PlacesWeakCallbackWrapper {
15041 declare var PlacesWeakCallbackWrapper: {
15042 prototype: PlacesWeakCallbackWrapper;
15043 new(callback: PlacesEventCallback): PlacesWeakCallbackWrapper;
15044 isInstance: IsInstance<PlacesWeakCallbackWrapper>;
15048 readonly description: string;
15049 readonly filename: string;
15050 readonly length: number;
15051 readonly name: string;
15052 item(index: number): MimeType | null;
15053 namedItem(name: string): MimeType | null;
15054 [index: number]: MimeType;
15057 declare var Plugin: {
15060 isInstance: IsInstance<Plugin>;
15063 interface PluginArray {
15064 readonly length: number;
15065 item(index: number): Plugin | null;
15066 namedItem(name: string): Plugin | null;
15068 [index: number]: Plugin;
15071 declare var PluginArray: {
15072 prototype: PluginArray;
15073 new(): PluginArray;
15074 isInstance: IsInstance<PluginArray>;
15077 interface PluginCrashedEvent extends Event {
15078 readonly gmpPlugin: boolean;
15079 readonly pluginDumpID: string;
15080 readonly pluginFilename: string | null;
15081 readonly pluginID: number;
15082 readonly pluginName: string;
15083 readonly submittedCrashReport: boolean;
15086 declare var PluginCrashedEvent: {
15087 prototype: PluginCrashedEvent;
15088 new(type: string, eventInitDict?: PluginCrashedEventInit): PluginCrashedEvent;
15089 isInstance: IsInstance<PluginCrashedEvent>;
15092 interface PointerEvent extends MouseEvent {
15093 readonly height: number;
15094 readonly isPrimary: boolean;
15095 readonly pointerId: number;
15096 readonly pointerType: string;
15097 readonly pressure: number;
15098 readonly tangentialPressure: number;
15099 readonly tiltX: number;
15100 readonly tiltY: number;
15101 readonly twist: number;
15102 readonly width: number;
15103 getCoalescedEvents(): PointerEvent[];
15104 getPredictedEvents(): PointerEvent[];
15107 declare var PointerEvent: {
15108 prototype: PointerEvent;
15109 new(type: string, eventInitDict?: PointerEventInit): PointerEvent;
15110 isInstance: IsInstance<PointerEvent>;
15113 interface PopStateEvent extends Event {
15114 readonly state: any;
15117 declare var PopStateEvent: {
15118 prototype: PopStateEvent;
15119 new(type: string, eventInitDict?: PopStateEventInit): PopStateEvent;
15120 isInstance: IsInstance<PopStateEvent>;
15123 interface PopoverInvokerElement {
15124 popoverTargetAction: string;
15125 popoverTargetElement: Element | null;
15128 interface PopupBlockedEvent extends Event {
15129 readonly popupWindowFeatures: string | null;
15130 readonly popupWindowName: string | null;
15131 readonly popupWindowURI: URI | null;
15132 readonly requestingWindow: Window | null;
15135 declare var PopupBlockedEvent: {
15136 prototype: PopupBlockedEvent;
15137 new(type: string, eventInitDict?: PopupBlockedEventInit): PopupBlockedEvent;
15138 isInstance: IsInstance<PopupBlockedEvent>;
15141 interface PopupPositionedEvent extends Event {
15142 readonly alignmentOffset: number;
15143 readonly alignmentPosition: string;
15144 readonly isAnchored: boolean;
15145 readonly popupAlignment: string;
15148 declare var PopupPositionedEvent: {
15149 prototype: PopupPositionedEvent;
15150 new(type: string, init?: PopupPositionedEventInit): PopupPositionedEvent;
15151 isInstance: IsInstance<PopupPositionedEvent>;
15154 interface PositionStateEvent extends Event {
15155 readonly duration: number;
15156 readonly playbackRate: number;
15157 readonly position: number;
15160 declare var PositionStateEvent: {
15161 prototype: PositionStateEvent;
15162 new(type: string, eventInitDict?: PositionStateEventInit): PositionStateEvent;
15163 isInstance: IsInstance<PositionStateEvent>;
15166 interface PrecompiledScript {
15167 readonly hasReturnValue: boolean;
15168 readonly url: string;
15169 executeInGlobal(global: any, options?: ExecuteInGlobalOptions): any;
15172 declare var PrecompiledScript: {
15173 prototype: PrecompiledScript;
15174 new(): PrecompiledScript;
15175 isInstance: IsInstance<PrecompiledScript>;
15178 interface Principal {
15181 /** Available only in secure contexts. */
15182 interface PrivateAttribution {
15183 measureConversion(options: PrivateAttributionConversionOptions): void;
15184 saveImpression(options: PrivateAttributionImpressionOptions): void;
15187 declare var PrivateAttribution: {
15188 prototype: PrivateAttribution;
15189 new(): PrivateAttribution;
15190 isInstance: IsInstance<PrivateAttribution>;
15193 interface ProcessMessageManager extends MessageSender, ProcessScriptLoader {
15194 readonly isInProcess: boolean;
15195 readonly osPid: number;
15198 declare var ProcessMessageManager: {
15199 prototype: ProcessMessageManager;
15200 new(): ProcessMessageManager;
15201 isInstance: IsInstance<ProcessMessageManager>;
15204 interface ProcessScriptLoader {
15205 getDelayedProcessScripts(): any[][];
15206 loadProcessScript(url: string, allowDelayedLoad: boolean): void;
15207 removeDelayedProcessScript(url: string): void;
15210 interface ProcessingInstruction extends CharacterData, LinkStyle {
15211 readonly target: string;
15214 declare var ProcessingInstruction: {
15215 prototype: ProcessingInstruction;
15216 new(): ProcessingInstruction;
15217 isInstance: IsInstance<ProcessingInstruction>;
15220 interface ProgressEvent extends Event {
15221 readonly lengthComputable: boolean;
15222 readonly loaded: number;
15223 readonly total: number;
15226 declare var ProgressEvent: {
15227 prototype: ProgressEvent;
15228 new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
15229 isInstance: IsInstance<ProgressEvent>;
15232 interface PromiseNativeHandler {
15235 interface PromiseRejectionEvent extends Event {
15236 readonly promise: Promise<any>;
15237 readonly reason: any;
15240 declare var PromiseRejectionEvent: {
15241 prototype: PromiseRejectionEvent;
15242 new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
15243 isInstance: IsInstance<PromiseRejectionEvent>;
15246 /** Available only in secure contexts. */
15247 interface PublicKeyCredential extends Credential {
15248 readonly authenticatorAttachment: string | null;
15249 readonly rawId: ArrayBuffer;
15250 readonly response: AuthenticatorResponse;
15251 getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
15255 declare var PublicKeyCredential: {
15256 prototype: PublicKeyCredential;
15257 new(): PublicKeyCredential;
15258 isInstance: IsInstance<PublicKeyCredential>;
15259 isConditionalMediationAvailable(): Promise<boolean>;
15260 isUserVerifyingPlatformAuthenticatorAvailable(): Promise<boolean>;
15261 parseCreationOptionsFromJSON(options: PublicKeyCredentialCreationOptionsJSON): PublicKeyCredentialCreationOptions;
15262 parseRequestOptionsFromJSON(options: PublicKeyCredentialRequestOptionsJSON): PublicKeyCredentialRequestOptions;
15265 interface PushManager {
15266 getSubscription(): Promise<PushSubscription | null>;
15267 permissionState(options?: PushSubscriptionOptionsInit): Promise<PermissionState>;
15268 subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
15271 declare var PushManager: {
15272 prototype: PushManager;
15273 new(scope: string): PushManager;
15274 isInstance: IsInstance<PushManager>;
15277 interface PushManagerImpl {
15278 getSubscription(): Promise<PushSubscription | null>;
15279 permissionState(options?: PushSubscriptionOptionsInit): Promise<PermissionState>;
15280 subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
15283 declare var PushManagerImpl: {
15284 prototype: PushManagerImpl;
15285 new(scope: string): PushManagerImpl;
15286 isInstance: IsInstance<PushManagerImpl>;
15289 interface PushSubscription {
15290 readonly endpoint: string;
15291 readonly expirationTime: EpochTimeStamp | null;
15292 readonly options: PushSubscriptionOptions;
15293 getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
15294 toJSON(): PushSubscriptionJSON;
15295 unsubscribe(): Promise<boolean>;
15298 declare var PushSubscription: {
15299 prototype: PushSubscription;
15300 new(initDict: PushSubscriptionInit): PushSubscription;
15301 isInstance: IsInstance<PushSubscription>;
15304 interface PushSubscriptionOptions {
15305 readonly applicationServerKey: ArrayBuffer | null;
15308 declare var PushSubscriptionOptions: {
15309 prototype: PushSubscriptionOptions;
15310 new(): PushSubscriptionOptions;
15311 isInstance: IsInstance<PushSubscriptionOptions>;
15314 interface RTCCertificate {
15315 readonly expires: DOMTimeStamp;
15318 declare var RTCCertificate: {
15319 prototype: RTCCertificate;
15320 new(): RTCCertificate;
15321 isInstance: IsInstance<RTCCertificate>;
15324 interface RTCDTMFSenderEventMap {
15325 "tonechange": Event;
15328 interface RTCDTMFSender extends EventTarget {
15329 ontonechange: ((this: RTCDTMFSender, ev: Event) => any) | null;
15330 readonly toneBuffer: string;
15331 insertDTMF(tones: string, duration?: number, interToneGap?: number): void;
15332 addEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15333 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15334 removeEventListener<K extends keyof RTCDTMFSenderEventMap>(type: K, listener: (this: RTCDTMFSender, ev: RTCDTMFSenderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15335 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15338 declare var RTCDTMFSender: {
15339 prototype: RTCDTMFSender;
15340 new(): RTCDTMFSender;
15341 isInstance: IsInstance<RTCDTMFSender>;
15344 interface RTCDTMFToneChangeEvent extends Event {
15345 readonly tone: string;
15348 declare var RTCDTMFToneChangeEvent: {
15349 prototype: RTCDTMFToneChangeEvent;
15350 new(type: string, eventInitDict?: RTCDTMFToneChangeEventInit): RTCDTMFToneChangeEvent;
15351 isInstance: IsInstance<RTCDTMFToneChangeEvent>;
15354 interface RTCDataChannelEventMap {
15355 "bufferedamountlow": Event;
15362 interface RTCDataChannel extends EventTarget {
15363 binaryType: RTCDataChannelType;
15364 readonly bufferedAmount: number;
15365 bufferedAmountLowThreshold: number;
15366 readonly id: number | null;
15367 readonly label: string;
15368 readonly maxPacketLifeTime: number | null;
15369 readonly maxRetransmits: number | null;
15370 readonly negotiated: boolean;
15371 onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
15372 onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
15373 onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
15374 onmessage: ((this: RTCDataChannel, ev: Event) => any) | null;
15375 onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
15376 readonly ordered: boolean;
15377 readonly protocol: string;
15378 readonly readyState: RTCDataChannelState;
15379 readonly reliable: boolean;
15381 send(data: string): void;
15382 send(data: Blob): void;
15383 send(data: ArrayBuffer): void;
15384 send(data: ArrayBufferView): void;
15385 addEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15386 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15387 removeEventListener<K extends keyof RTCDataChannelEventMap>(type: K, listener: (this: RTCDataChannel, ev: RTCDataChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15388 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15391 declare var RTCDataChannel: {
15392 prototype: RTCDataChannel;
15393 new(): RTCDataChannel;
15394 isInstance: IsInstance<RTCDataChannel>;
15397 interface RTCDataChannelEvent extends Event {
15398 readonly channel: RTCDataChannel;
15401 declare var RTCDataChannelEvent: {
15402 prototype: RTCDataChannelEvent;
15403 new(type: string, eventInitDict: RTCDataChannelEventInit): RTCDataChannelEvent;
15404 isInstance: IsInstance<RTCDataChannelEvent>;
15407 interface RTCDtlsTransportEventMap {
15408 "statechange": Event;
15411 interface RTCDtlsTransport extends EventTarget {
15412 readonly iceTransport: RTCIceTransport;
15413 onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null;
15414 readonly state: RTCDtlsTransportState;
15415 addEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15416 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15417 removeEventListener<K extends keyof RTCDtlsTransportEventMap>(type: K, listener: (this: RTCDtlsTransport, ev: RTCDtlsTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15418 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15421 declare var RTCDtlsTransport: {
15422 prototype: RTCDtlsTransport;
15423 new(): RTCDtlsTransport;
15424 isInstance: IsInstance<RTCDtlsTransport>;
15427 interface RTCEncodedAudioFrame {
15429 readonly timestamp: number;
15430 getMetadata(): RTCEncodedAudioFrameMetadata;
15433 declare var RTCEncodedAudioFrame: {
15434 prototype: RTCEncodedAudioFrame;
15435 new(): RTCEncodedAudioFrame;
15436 isInstance: IsInstance<RTCEncodedAudioFrame>;
15439 interface RTCEncodedVideoFrame {
15441 readonly timestamp: number;
15442 readonly type: RTCEncodedVideoFrameType;
15443 getMetadata(): RTCEncodedVideoFrameMetadata;
15446 declare var RTCEncodedVideoFrame: {
15447 prototype: RTCEncodedVideoFrame;
15448 new(): RTCEncodedVideoFrame;
15449 isInstance: IsInstance<RTCEncodedVideoFrame>;
15452 interface RTCIceCandidate {
15453 readonly address: string | null;
15454 readonly candidate: string;
15455 readonly component: RTCIceComponent | null;
15456 readonly foundation: string | null;
15457 readonly port: number | null;
15458 readonly priority: number | null;
15459 readonly protocol: RTCIceProtocol | null;
15460 readonly relatedAddress: string | null;
15461 readonly relatedPort: number | null;
15462 readonly sdpMLineIndex: number | null;
15463 readonly sdpMid: string | null;
15464 readonly tcpType: RTCIceTcpCandidateType | null;
15465 readonly type: RTCIceCandidateType | null;
15466 readonly usernameFragment: string | null;
15467 toJSON(): RTCIceCandidateInit;
15470 declare var RTCIceCandidate: {
15471 prototype: RTCIceCandidate;
15472 new(candidateInitDict?: RTCIceCandidateInit): RTCIceCandidate;
15473 isInstance: IsInstance<RTCIceCandidate>;
15476 interface RTCIceTransportEventMap {
15477 "gatheringstatechange": Event;
15478 "statechange": Event;
15481 interface RTCIceTransport extends EventTarget {
15482 readonly gatheringState: RTCIceGathererState;
15483 ongatheringstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
15484 onstatechange: ((this: RTCIceTransport, ev: Event) => any) | null;
15485 readonly state: RTCIceTransportState;
15486 addEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15487 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15488 removeEventListener<K extends keyof RTCIceTransportEventMap>(type: K, listener: (this: RTCIceTransport, ev: RTCIceTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15489 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15492 declare var RTCIceTransport: {
15493 prototype: RTCIceTransport;
15494 new(): RTCIceTransport;
15495 isInstance: IsInstance<RTCIceTransport>;
15498 interface RTCIdentityProviderRegistrar {
15499 readonly hasIdp: boolean;
15500 generateAssertion(contents: string, origin: string, options?: RTCIdentityProviderOptions): Promise<RTCIdentityAssertionResult>;
15501 register(idp: RTCIdentityProvider): void;
15502 validateAssertion(assertion: string, origin: string): Promise<RTCIdentityValidationResult>;
15505 interface RTCPeerConnectionEventMap {
15506 "addstream": Event;
15508 "connectionstatechange": Event;
15509 "datachannel": Event;
15510 "icecandidate": Event;
15511 "iceconnectionstatechange": Event;
15512 "icegatheringstatechange": Event;
15513 "negotiationneeded": Event;
15514 "signalingstatechange": Event;
15518 interface RTCPeerConnection extends EventTarget {
15519 readonly canTrickleIceCandidates: boolean | null;
15520 readonly connectionState: RTCPeerConnectionState;
15521 readonly currentLocalDescription: RTCSessionDescription | null;
15522 readonly currentRemoteDescription: RTCSessionDescription | null;
15523 readonly iceConnectionState: RTCIceConnectionState;
15524 readonly iceGatheringState: RTCIceGatheringState;
15526 readonly idpLoginUrl: string | null;
15527 readonly localDescription: RTCSessionDescription | null;
15528 onaddstream: ((this: RTCPeerConnection, ev: Event) => any) | null;
15529 onaddtrack: ((this: RTCPeerConnection, ev: Event) => any) | null;
15530 onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
15531 ondatachannel: ((this: RTCPeerConnection, ev: Event) => any) | null;
15532 onicecandidate: ((this: RTCPeerConnection, ev: Event) => any) | null;
15533 oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
15534 onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
15535 onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
15536 onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
15537 ontrack: ((this: RTCPeerConnection, ev: Event) => any) | null;
15538 readonly peerIdentity: Promise<RTCIdentityAssertion>;
15539 readonly pendingLocalDescription: RTCSessionDescription | null;
15540 readonly pendingRemoteDescription: RTCSessionDescription | null;
15541 readonly remoteDescription: RTCSessionDescription | null;
15542 readonly sctp: RTCSctpTransport | null;
15543 readonly signalingState: RTCSignalingState;
15544 addIceCandidate(candidate: RTCIceCandidateInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
15545 addStream(stream: MediaStream): void;
15546 addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
15547 addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
15549 createAnswer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
15550 createDataChannel(label: string, dataChannelDict?: RTCDataChannelInit): RTCDataChannel;
15551 createOffer(successCallback: RTCSessionDescriptionCallback, failureCallback: RTCPeerConnectionErrorCallback, options?: RTCOfferOptions): Promise<void>;
15552 getConfiguration(): RTCConfiguration;
15553 getIdentityAssertion(): Promise<string>;
15554 getLocalStreams(): MediaStream[];
15555 getReceivers(): RTCRtpReceiver[];
15556 getRemoteStreams(): MediaStream[];
15557 getSenders(): RTCRtpSender[];
15558 getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport>;
15559 getTransceivers(): RTCRtpTransceiver[];
15560 mozDisablePacketDump(level: number, type: mozPacketDumpType, sending: boolean): void;
15561 mozEnablePacketDump(level: number, type: mozPacketDumpType, sending: boolean): void;
15562 mozSetPacketCallback(callback: mozPacketCallback): void;
15563 removeTrack(sender: RTCRtpSender): void;
15564 restartIce(): void;
15565 setConfiguration(configuration?: RTCConfiguration): void;
15566 setIdentityProvider(provider: string, options?: RTCIdentityProviderOptions): void;
15567 setLocalDescription(description: RTCLocalSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
15568 setRemoteDescription(description: RTCSessionDescriptionInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise<void>;
15569 addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15570 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15571 removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15572 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15575 declare var RTCPeerConnection: {
15576 prototype: RTCPeerConnection;
15577 new(configuration?: RTCConfiguration): RTCPeerConnection;
15578 isInstance: IsInstance<RTCPeerConnection>;
15579 generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate>;
15582 interface RTCPeerConnectionIceEvent extends Event {
15583 readonly candidate: RTCIceCandidate | null;
15586 declare var RTCPeerConnectionIceEvent: {
15587 prototype: RTCPeerConnectionIceEvent;
15588 new(type: string, eventInitDict?: RTCPeerConnectionIceEventInit): RTCPeerConnectionIceEvent;
15589 isInstance: IsInstance<RTCPeerConnectionIceEvent>;
15592 interface RTCPeerConnectionStatic {
15593 registerPeerConnectionLifecycleCallback(cb: PeerConnectionLifecycleCallback): void;
15596 declare var RTCPeerConnectionStatic: {
15597 prototype: RTCPeerConnectionStatic;
15598 new(): RTCPeerConnectionStatic;
15599 isInstance: IsInstance<RTCPeerConnectionStatic>;
15602 interface RTCRtpReceiver {
15603 jitterBufferTarget: DOMHighResTimeStamp | null;
15604 readonly track: MediaStreamTrack;
15605 transform: RTCRtpTransform | null;
15606 readonly transport: RTCDtlsTransport | null;
15607 getContributingSources(): RTCRtpContributingSource[];
15608 getParameters(): RTCRtpReceiveParameters;
15609 getStats(): Promise<RTCStatsReport>;
15610 getSynchronizationSources(): RTCRtpSynchronizationSource[];
15611 mozInsertAudioLevelForContributingSource(source: number, timestamp: DOMHighResTimeStamp, rtpTimestamp: number, hasLevel: boolean, level: number): void;
15614 declare var RTCRtpReceiver: {
15615 prototype: RTCRtpReceiver;
15616 new(): RTCRtpReceiver;
15617 isInstance: IsInstance<RTCRtpReceiver>;
15618 getCapabilities(kind: string): RTCRtpCapabilities | null;
15621 interface RTCRtpScriptTransform {
15624 declare var RTCRtpScriptTransform: {
15625 prototype: RTCRtpScriptTransform;
15626 new(worker: Worker, options?: any, transfer?: any[]): RTCRtpScriptTransform;
15627 isInstance: IsInstance<RTCRtpScriptTransform>;
15630 interface RTCRtpSender {
15631 readonly dtmf: RTCDTMFSender | null;
15632 readonly track: MediaStreamTrack | null;
15633 transform: RTCRtpTransform | null;
15634 readonly transport: RTCDtlsTransport | null;
15635 getParameters(): RTCRtpSendParameters;
15636 getStats(): Promise<RTCStatsReport>;
15637 getStreams(): MediaStream[];
15638 replaceTrack(withTrack: MediaStreamTrack | null): Promise<void>;
15639 setParameters(parameters: RTCRtpSendParameters): Promise<void>;
15640 setStreams(...streams: MediaStream[]): void;
15641 setStreamsImpl(...streams: MediaStream[]): void;
15642 setTrack(track: MediaStreamTrack | null): void;
15645 declare var RTCRtpSender: {
15646 prototype: RTCRtpSender;
15647 new(): RTCRtpSender;
15648 isInstance: IsInstance<RTCRtpSender>;
15649 getCapabilities(kind: string): RTCRtpCapabilities | null;
15652 interface RTCRtpTransceiver {
15653 readonly currentDirection: RTCRtpTransceiverDirection | null;
15654 direction: RTCRtpTransceiverDirection;
15655 readonly mid: string | null;
15656 readonly receiver: RTCRtpReceiver;
15657 readonly sender: RTCRtpSender;
15658 readonly stopped: boolean;
15660 hasBeenUsedToSend(): boolean;
15661 setCodecPreferences(codecs: RTCRtpCodec[]): void;
15662 setDirectionInternal(direction: RTCRtpTransceiverDirection): void;
15666 declare var RTCRtpTransceiver: {
15667 prototype: RTCRtpTransceiver;
15668 new(): RTCRtpTransceiver;
15669 isInstance: IsInstance<RTCRtpTransceiver>;
15672 interface RTCSctpTransportEventMap {
15673 "statechange": Event;
15676 interface RTCSctpTransport extends EventTarget {
15677 readonly maxChannels: number | null;
15678 readonly maxMessageSize: number;
15679 onstatechange: ((this: RTCSctpTransport, ev: Event) => any) | null;
15680 readonly state: RTCSctpTransportState;
15681 readonly transport: RTCDtlsTransport;
15682 addEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
15683 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
15684 removeEventListener<K extends keyof RTCSctpTransportEventMap>(type: K, listener: (this: RTCSctpTransport, ev: RTCSctpTransportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
15685 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
15688 declare var RTCSctpTransport: {
15689 prototype: RTCSctpTransport;
15690 new(): RTCSctpTransport;
15691 isInstance: IsInstance<RTCSctpTransport>;
15694 interface RTCSessionDescription {
15700 declare var RTCSessionDescription: {
15701 prototype: RTCSessionDescription;
15702 new(descriptionInitDict: RTCSessionDescriptionInit): RTCSessionDescription;
15703 isInstance: IsInstance<RTCSessionDescription>;
15706 interface RTCStatsReport {
15707 forEach(callbackfn: (value: any, key: string, parent: RTCStatsReport) => void, thisArg?: any): void;
15710 declare var RTCStatsReport: {
15711 prototype: RTCStatsReport;
15712 new(): RTCStatsReport;
15713 isInstance: IsInstance<RTCStatsReport>;
15716 interface RTCTrackEvent extends Event {
15717 readonly receiver: RTCRtpReceiver;
15718 readonly streams: MediaStream[];
15719 readonly track: MediaStreamTrack;
15720 readonly transceiver: RTCRtpTransceiver;
15723 declare var RTCTrackEvent: {
15724 prototype: RTCTrackEvent;
15725 new(type: string, eventInitDict: RTCTrackEventInit): RTCTrackEvent;
15726 isInstance: IsInstance<RTCTrackEvent>;
15729 interface RadioNodeList extends NodeList {
15733 declare var RadioNodeList: {
15734 prototype: RadioNodeList;
15735 new(): RadioNodeList;
15736 isInstance: IsInstance<RadioNodeList>;
15739 interface Range extends AbstractRange {
15740 readonly commonAncestorContainer: Node;
15741 cloneContents(): DocumentFragment;
15742 cloneRange(): Range;
15743 collapse(toStart?: boolean): void;
15744 compareBoundaryPoints(how: number, sourceRange: Range): number;
15745 comparePoint(node: Node, offset: number): number;
15746 createContextualFragment(fragment: string): DocumentFragment;
15747 deleteContents(): void;
15749 extractContents(): DocumentFragment;
15750 getBoundingClientRect(): DOMRect;
15751 getClientRects(): DOMRectList | null;
15752 getClientRectsAndTexts(): ClientRectsAndTexts;
15753 insertNode(node: Node): void;
15754 intersectsNode(node: Node): boolean;
15755 isPointInRange(node: Node, offset: number): boolean;
15756 selectNode(refNode: Node): void;
15757 selectNodeContents(refNode: Node): void;
15758 setEnd(refNode: Node, offset: number): void;
15759 setEndAfter(refNode: Node): void;
15760 setEndAllowCrossShadowBoundary(refNode: Node, offset: number): void;
15761 setEndBefore(refNode: Node): void;
15762 setStart(refNode: Node, offset: number): void;
15763 setStartAfter(refNode: Node): void;
15764 setStartAllowCrossShadowBoundary(refNode: Node, offset: number): void;
15765 setStartBefore(refNode: Node): void;
15766 surroundContents(newParent: Node): void;
15767 toString(): string;
15768 readonly START_TO_START: 0;
15769 readonly START_TO_END: 1;
15770 readonly END_TO_END: 2;
15771 readonly END_TO_START: 3;
15774 declare var Range: {
15777 readonly START_TO_START: 0;
15778 readonly START_TO_END: 1;
15779 readonly END_TO_END: 2;
15780 readonly END_TO_START: 3;
15781 isInstance: IsInstance<Range>;
15784 interface ReadableByteStreamController {
15785 readonly byobRequest: ReadableStreamBYOBRequest | null;
15786 readonly desiredSize: number | null;
15788 enqueue(chunk: ArrayBufferView): void;
15789 error(e?: any): void;
15792 declare var ReadableByteStreamController: {
15793 prototype: ReadableByteStreamController;
15794 new(): ReadableByteStreamController;
15795 isInstance: IsInstance<ReadableByteStreamController>;
15798 interface ReadableStream {
15799 readonly locked: boolean;
15800 cancel(reason?: any): Promise<void>;
15801 getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader;
15802 pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream;
15803 pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise<void>;
15804 tee(): ReadableStream[];
15807 declare var ReadableStream: {
15808 prototype: ReadableStream;
15809 new(underlyingSource?: any, strategy?: QueuingStrategy): ReadableStream;
15810 isInstance: IsInstance<ReadableStream>;
15811 from(asyncIterable: any): ReadableStream;
15814 interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
15815 read(view: ArrayBufferView): Promise<ReadableStreamReadResult>;
15816 releaseLock(): void;
15819 declare var ReadableStreamBYOBReader: {
15820 prototype: ReadableStreamBYOBReader;
15821 new(stream: ReadableStream): ReadableStreamBYOBReader;
15822 isInstance: IsInstance<ReadableStreamBYOBReader>;
15825 interface ReadableStreamBYOBRequest {
15826 readonly view: ArrayBufferView | null;
15827 respond(bytesWritten: number): void;
15828 respondWithNewView(view: ArrayBufferView): void;
15831 declare var ReadableStreamBYOBRequest: {
15832 prototype: ReadableStreamBYOBRequest;
15833 new(): ReadableStreamBYOBRequest;
15834 isInstance: IsInstance<ReadableStreamBYOBRequest>;
15837 interface ReadableStreamDefaultController {
15838 readonly desiredSize: number | null;
15840 enqueue(chunk?: any): void;
15841 error(e?: any): void;
15844 declare var ReadableStreamDefaultController: {
15845 prototype: ReadableStreamDefaultController;
15846 new(): ReadableStreamDefaultController;
15847 isInstance: IsInstance<ReadableStreamDefaultController>;
15850 interface ReadableStreamDefaultReader extends ReadableStreamGenericReader {
15851 read(): Promise<ReadableStreamReadResult>;
15852 releaseLock(): void;
15855 declare var ReadableStreamDefaultReader: {
15856 prototype: ReadableStreamDefaultReader;
15857 new(stream: ReadableStream): ReadableStreamDefaultReader;
15858 isInstance: IsInstance<ReadableStreamDefaultReader>;
15861 interface ReadableStreamGenericReader {
15862 readonly closed: Promise<undefined>;
15863 cancel(reason?: any): Promise<void>;
15866 interface ReferrerInfo {
15869 interface RemoteTab {
15873 readonly body: ReportBody | null;
15874 readonly type: string;
15875 readonly url: string;
15879 declare var Report: {
15882 isInstance: IsInstance<Report>;
15885 interface ReportBody {
15889 declare var ReportBody: {
15890 prototype: ReportBody;
15892 isInstance: IsInstance<ReportBody>;
15895 interface ReportingObserver {
15896 disconnect(): void;
15898 takeRecords(): ReportList;
15901 declare var ReportingObserver: {
15902 prototype: ReportingObserver;
15903 new(callback: ReportingObserverCallback, options?: ReportingObserverOptions): ReportingObserver;
15904 isInstance: IsInstance<ReportingObserver>;
15907 interface Request extends Body {
15908 readonly cache: RequestCache;
15909 readonly credentials: RequestCredentials;
15910 readonly destination: RequestDestination;
15911 readonly headers: Headers;
15912 readonly integrity: string;
15913 readonly keepalive: boolean;
15914 readonly method: string;
15915 readonly mode: RequestMode;
15916 readonly mozErrors: boolean;
15917 readonly redirect: RequestRedirect;
15918 readonly referrer: string;
15919 readonly referrerPolicy: ReferrerPolicy;
15920 readonly signal: AbortSignal;
15921 readonly url: string;
15923 overrideContentPolicyType(context: nsContentPolicyType): void;
15926 declare var Request: {
15927 prototype: Request;
15928 new(input: RequestInfo | URL, init?: RequestInit): Request;
15929 isInstance: IsInstance<Request>;
15932 interface ResizeObserver {
15933 disconnect(): void;
15934 observe(target: Element, options?: ResizeObserverOptions): void;
15935 unobserve(target: Element): void;
15938 declare var ResizeObserver: {
15939 prototype: ResizeObserver;
15940 new(callback: ResizeObserverCallback): ResizeObserver;
15941 isInstance: IsInstance<ResizeObserver>;
15944 interface ResizeObserverEntry {
15945 readonly borderBoxSize: ResizeObserverSize[];
15946 readonly contentBoxSize: ResizeObserverSize[];
15947 readonly contentRect: DOMRectReadOnly;
15948 readonly devicePixelContentBoxSize: ResizeObserverSize[];
15949 readonly target: Element;
15952 declare var ResizeObserverEntry: {
15953 prototype: ResizeObserverEntry;
15954 new(): ResizeObserverEntry;
15955 isInstance: IsInstance<ResizeObserverEntry>;
15958 interface ResizeObserverSize {
15959 readonly blockSize: number;
15960 readonly inlineSize: number;
15963 declare var ResizeObserverSize: {
15964 prototype: ResizeObserverSize;
15965 new(): ResizeObserverSize;
15966 isInstance: IsInstance<ResizeObserverSize>;
15969 interface Response extends Body {
15970 readonly body: ReadableStream | null;
15971 readonly hasCacheInfoChannel: boolean;
15972 readonly headers: Headers;
15973 readonly ok: boolean;
15974 readonly redirected: boolean;
15975 readonly status: number;
15976 readonly statusText: string;
15977 readonly type: ResponseType;
15978 readonly url: string;
15980 cloneUnfiltered(): Response;
15983 declare var Response: {
15984 prototype: Response;
15985 new(body?: Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string | null, init?: ResponseInit): Response;
15986 isInstance: IsInstance<Response>;
15988 json(data: any, init?: ResponseInit): Response;
15989 redirect(url: string, status?: number): Response;
15992 interface SVGAElement extends SVGGraphicsElement, SVGURIReference {
15996 referrerPolicy: string;
15998 readonly relList: DOMTokenList;
15999 readonly target: SVGAnimatedString;
16002 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16003 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16004 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16005 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16008 declare var SVGAElement: {
16009 prototype: SVGAElement;
16010 new(): SVGAElement;
16011 isInstance: IsInstance<SVGAElement>;
16014 interface SVGAngle {
16015 readonly unitType: number;
16017 valueAsString: string;
16018 valueInSpecifiedUnits: number;
16019 convertToSpecifiedUnits(unitType: number): void;
16020 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
16021 readonly SVG_ANGLETYPE_UNKNOWN: 0;
16022 readonly SVG_ANGLETYPE_UNSPECIFIED: 1;
16023 readonly SVG_ANGLETYPE_DEG: 2;
16024 readonly SVG_ANGLETYPE_RAD: 3;
16025 readonly SVG_ANGLETYPE_GRAD: 4;
16028 declare var SVGAngle: {
16029 prototype: SVGAngle;
16031 readonly SVG_ANGLETYPE_UNKNOWN: 0;
16032 readonly SVG_ANGLETYPE_UNSPECIFIED: 1;
16033 readonly SVG_ANGLETYPE_DEG: 2;
16034 readonly SVG_ANGLETYPE_RAD: 3;
16035 readonly SVG_ANGLETYPE_GRAD: 4;
16036 isInstance: IsInstance<SVGAngle>;
16039 interface SVGAnimateElement extends SVGAnimationElement {
16040 addEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16041 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16042 removeEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16043 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16046 declare var SVGAnimateElement: {
16047 prototype: SVGAnimateElement;
16048 new(): SVGAnimateElement;
16049 isInstance: IsInstance<SVGAnimateElement>;
16052 interface SVGAnimateMotionElement extends SVGAnimationElement {
16053 addEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16054 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16055 removeEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateMotionElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16056 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16059 declare var SVGAnimateMotionElement: {
16060 prototype: SVGAnimateMotionElement;
16061 new(): SVGAnimateMotionElement;
16062 isInstance: IsInstance<SVGAnimateMotionElement>;
16065 interface SVGAnimateTransformElement extends SVGAnimationElement {
16066 addEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16067 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16068 removeEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimateTransformElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16069 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16072 declare var SVGAnimateTransformElement: {
16073 prototype: SVGAnimateTransformElement;
16074 new(): SVGAnimateTransformElement;
16075 isInstance: IsInstance<SVGAnimateTransformElement>;
16078 interface SVGAnimatedAngle {
16079 readonly animVal: SVGAngle;
16080 readonly baseVal: SVGAngle;
16083 declare var SVGAnimatedAngle: {
16084 prototype: SVGAnimatedAngle;
16085 new(): SVGAnimatedAngle;
16086 isInstance: IsInstance<SVGAnimatedAngle>;
16089 interface SVGAnimatedBoolean {
16090 readonly animVal: boolean;
16094 declare var SVGAnimatedBoolean: {
16095 prototype: SVGAnimatedBoolean;
16096 new(): SVGAnimatedBoolean;
16097 isInstance: IsInstance<SVGAnimatedBoolean>;
16100 interface SVGAnimatedEnumeration {
16101 readonly animVal: number;
16105 declare var SVGAnimatedEnumeration: {
16106 prototype: SVGAnimatedEnumeration;
16107 new(): SVGAnimatedEnumeration;
16108 isInstance: IsInstance<SVGAnimatedEnumeration>;
16111 interface SVGAnimatedInteger {
16112 readonly animVal: number;
16116 declare var SVGAnimatedInteger: {
16117 prototype: SVGAnimatedInteger;
16118 new(): SVGAnimatedInteger;
16119 isInstance: IsInstance<SVGAnimatedInteger>;
16122 interface SVGAnimatedLength {
16123 readonly animVal: SVGLength;
16124 readonly baseVal: SVGLength;
16127 declare var SVGAnimatedLength: {
16128 prototype: SVGAnimatedLength;
16129 new(): SVGAnimatedLength;
16130 isInstance: IsInstance<SVGAnimatedLength>;
16133 interface SVGAnimatedLengthList {
16134 readonly animVal: SVGLengthList;
16135 readonly baseVal: SVGLengthList;
16138 declare var SVGAnimatedLengthList: {
16139 prototype: SVGAnimatedLengthList;
16140 new(): SVGAnimatedLengthList;
16141 isInstance: IsInstance<SVGAnimatedLengthList>;
16144 interface SVGAnimatedNumber {
16145 readonly animVal: number;
16149 declare var SVGAnimatedNumber: {
16150 prototype: SVGAnimatedNumber;
16151 new(): SVGAnimatedNumber;
16152 isInstance: IsInstance<SVGAnimatedNumber>;
16155 interface SVGAnimatedNumberList {
16156 readonly animVal: SVGNumberList;
16157 readonly baseVal: SVGNumberList;
16160 declare var SVGAnimatedNumberList: {
16161 prototype: SVGAnimatedNumberList;
16162 new(): SVGAnimatedNumberList;
16163 isInstance: IsInstance<SVGAnimatedNumberList>;
16166 interface SVGAnimatedPathData {
16167 readonly animatedPathSegList: SVGPathSegList;
16168 readonly pathSegList: SVGPathSegList;
16171 interface SVGAnimatedPoints {
16172 readonly animatedPoints: SVGPointList;
16173 readonly points: SVGPointList;
16176 interface SVGAnimatedPreserveAspectRatio {
16177 readonly animVal: SVGPreserveAspectRatio;
16178 readonly baseVal: SVGPreserveAspectRatio;
16181 declare var SVGAnimatedPreserveAspectRatio: {
16182 prototype: SVGAnimatedPreserveAspectRatio;
16183 new(): SVGAnimatedPreserveAspectRatio;
16184 isInstance: IsInstance<SVGAnimatedPreserveAspectRatio>;
16187 interface SVGAnimatedRect {
16188 readonly animVal: SVGRect | null;
16189 readonly baseVal: SVGRect | null;
16192 declare var SVGAnimatedRect: {
16193 prototype: SVGAnimatedRect;
16194 new(): SVGAnimatedRect;
16195 isInstance: IsInstance<SVGAnimatedRect>;
16198 interface SVGAnimatedString {
16199 readonly animVal: string;
16203 declare var SVGAnimatedString: {
16204 prototype: SVGAnimatedString;
16205 new(): SVGAnimatedString;
16206 isInstance: IsInstance<SVGAnimatedString>;
16209 interface SVGAnimatedTransformList {
16210 readonly animVal: SVGTransformList;
16211 readonly baseVal: SVGTransformList;
16214 declare var SVGAnimatedTransformList: {
16215 prototype: SVGAnimatedTransformList;
16216 new(): SVGAnimatedTransformList;
16217 isInstance: IsInstance<SVGAnimatedTransformList>;
16220 interface SVGAnimationElementEventMap extends SVGElementEventMap {
16226 interface SVGAnimationElement extends SVGElement, SVGTests {
16227 onbegin: ((this: SVGAnimationElement, ev: Event) => any) | null;
16228 onend: ((this: SVGAnimationElement, ev: Event) => any) | null;
16229 onrepeat: ((this: SVGAnimationElement, ev: Event) => any) | null;
16230 readonly targetElement: SVGElement | null;
16231 beginElement(): void;
16232 beginElementAt(offset: number): void;
16233 endElement(): void;
16234 endElementAt(offset: number): void;
16235 getCurrentTime(): number;
16236 getSimpleDuration(): number;
16237 getStartTime(): number;
16238 addEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16239 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16240 removeEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGAnimationElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16241 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16244 declare var SVGAnimationElement: {
16245 prototype: SVGAnimationElement;
16246 new(): SVGAnimationElement;
16247 isInstance: IsInstance<SVGAnimationElement>;
16250 interface SVGCircleElement extends SVGGeometryElement {
16251 readonly cx: SVGAnimatedLength;
16252 readonly cy: SVGAnimatedLength;
16253 readonly r: SVGAnimatedLength;
16254 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16255 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16256 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGCircleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16257 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16260 declare var SVGCircleElement: {
16261 prototype: SVGCircleElement;
16262 new(): SVGCircleElement;
16263 isInstance: IsInstance<SVGCircleElement>;
16266 interface SVGClipPathElement extends SVGElement {
16267 readonly clipPathUnits: SVGAnimatedEnumeration;
16268 readonly transform: SVGAnimatedTransformList;
16269 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16270 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16271 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGClipPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16272 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16275 declare var SVGClipPathElement: {
16276 prototype: SVGClipPathElement;
16277 new(): SVGClipPathElement;
16278 isInstance: IsInstance<SVGClipPathElement>;
16281 interface SVGComponentTransferFunctionElement extends SVGElement {
16282 readonly amplitude: SVGAnimatedNumber;
16283 readonly exponent: SVGAnimatedNumber;
16284 readonly intercept: SVGAnimatedNumber;
16285 readonly offset: SVGAnimatedNumber;
16286 readonly slope: SVGAnimatedNumber;
16287 readonly tableValues: SVGAnimatedNumberList;
16288 readonly type: SVGAnimatedEnumeration;
16289 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: 0;
16290 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: 1;
16291 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: 2;
16292 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: 3;
16293 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: 4;
16294 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: 5;
16295 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16296 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16297 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGComponentTransferFunctionElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16298 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16301 declare var SVGComponentTransferFunctionElement: {
16302 prototype: SVGComponentTransferFunctionElement;
16303 new(): SVGComponentTransferFunctionElement;
16304 readonly SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: 0;
16305 readonly SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: 1;
16306 readonly SVG_FECOMPONENTTRANSFER_TYPE_TABLE: 2;
16307 readonly SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: 3;
16308 readonly SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: 4;
16309 readonly SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: 5;
16310 isInstance: IsInstance<SVGComponentTransferFunctionElement>;
16313 interface SVGDefsElement extends SVGGraphicsElement {
16314 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16315 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16316 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDefsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16317 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16320 declare var SVGDefsElement: {
16321 prototype: SVGDefsElement;
16322 new(): SVGDefsElement;
16323 isInstance: IsInstance<SVGDefsElement>;
16326 interface SVGDescElement extends SVGElement {
16327 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16328 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16329 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGDescElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16330 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16333 declare var SVGDescElement: {
16334 prototype: SVGDescElement;
16335 new(): SVGDescElement;
16336 isInstance: IsInstance<SVGDescElement>;
16339 interface SVGElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, OnErrorEventHandlerForNodesEventMap, TouchEventHandlersEventMap {
16343 interface SVGElement extends Element, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrForeignElement, OnErrorEventHandlerForNodes, TouchEventHandlers {
16344 readonly className: SVGAnimatedString;
16347 readonly ownerSVGElement: SVGSVGElement | null;
16348 readonly viewportElement: SVGElement | null;
16349 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16350 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16351 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16352 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16355 declare var SVGElement: {
16356 prototype: SVGElement;
16358 isInstance: IsInstance<SVGElement>;
16361 interface SVGEllipseElement extends SVGGeometryElement {
16362 readonly cx: SVGAnimatedLength;
16363 readonly cy: SVGAnimatedLength;
16364 readonly rx: SVGAnimatedLength;
16365 readonly ry: SVGAnimatedLength;
16366 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16367 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16368 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGEllipseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16369 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16372 declare var SVGEllipseElement: {
16373 prototype: SVGEllipseElement;
16374 new(): SVGEllipseElement;
16375 isInstance: IsInstance<SVGEllipseElement>;
16378 interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16379 readonly in1: SVGAnimatedString;
16380 readonly in2: SVGAnimatedString;
16381 readonly mode: SVGAnimatedEnumeration;
16382 readonly SVG_FEBLEND_MODE_UNKNOWN: 0;
16383 readonly SVG_FEBLEND_MODE_NORMAL: 1;
16384 readonly SVG_FEBLEND_MODE_MULTIPLY: 2;
16385 readonly SVG_FEBLEND_MODE_SCREEN: 3;
16386 readonly SVG_FEBLEND_MODE_DARKEN: 4;
16387 readonly SVG_FEBLEND_MODE_LIGHTEN: 5;
16388 readonly SVG_FEBLEND_MODE_OVERLAY: 6;
16389 readonly SVG_FEBLEND_MODE_COLOR_DODGE: 7;
16390 readonly SVG_FEBLEND_MODE_COLOR_BURN: 8;
16391 readonly SVG_FEBLEND_MODE_HARD_LIGHT: 9;
16392 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: 10;
16393 readonly SVG_FEBLEND_MODE_DIFFERENCE: 11;
16394 readonly SVG_FEBLEND_MODE_EXCLUSION: 12;
16395 readonly SVG_FEBLEND_MODE_HUE: 13;
16396 readonly SVG_FEBLEND_MODE_SATURATION: 14;
16397 readonly SVG_FEBLEND_MODE_COLOR: 15;
16398 readonly SVG_FEBLEND_MODE_LUMINOSITY: 16;
16399 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16400 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16401 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEBlendElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16402 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16405 declare var SVGFEBlendElement: {
16406 prototype: SVGFEBlendElement;
16407 new(): SVGFEBlendElement;
16408 readonly SVG_FEBLEND_MODE_UNKNOWN: 0;
16409 readonly SVG_FEBLEND_MODE_NORMAL: 1;
16410 readonly SVG_FEBLEND_MODE_MULTIPLY: 2;
16411 readonly SVG_FEBLEND_MODE_SCREEN: 3;
16412 readonly SVG_FEBLEND_MODE_DARKEN: 4;
16413 readonly SVG_FEBLEND_MODE_LIGHTEN: 5;
16414 readonly SVG_FEBLEND_MODE_OVERLAY: 6;
16415 readonly SVG_FEBLEND_MODE_COLOR_DODGE: 7;
16416 readonly SVG_FEBLEND_MODE_COLOR_BURN: 8;
16417 readonly SVG_FEBLEND_MODE_HARD_LIGHT: 9;
16418 readonly SVG_FEBLEND_MODE_SOFT_LIGHT: 10;
16419 readonly SVG_FEBLEND_MODE_DIFFERENCE: 11;
16420 readonly SVG_FEBLEND_MODE_EXCLUSION: 12;
16421 readonly SVG_FEBLEND_MODE_HUE: 13;
16422 readonly SVG_FEBLEND_MODE_SATURATION: 14;
16423 readonly SVG_FEBLEND_MODE_COLOR: 15;
16424 readonly SVG_FEBLEND_MODE_LUMINOSITY: 16;
16425 isInstance: IsInstance<SVGFEBlendElement>;
16428 interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16429 readonly in1: SVGAnimatedString;
16430 readonly type: SVGAnimatedEnumeration;
16431 readonly values: SVGAnimatedNumberList;
16432 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: 0;
16433 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: 1;
16434 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: 2;
16435 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: 3;
16436 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: 4;
16437 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16438 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16439 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEColorMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16440 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16443 declare var SVGFEColorMatrixElement: {
16444 prototype: SVGFEColorMatrixElement;
16445 new(): SVGFEColorMatrixElement;
16446 readonly SVG_FECOLORMATRIX_TYPE_UNKNOWN: 0;
16447 readonly SVG_FECOLORMATRIX_TYPE_MATRIX: 1;
16448 readonly SVG_FECOLORMATRIX_TYPE_SATURATE: 2;
16449 readonly SVG_FECOLORMATRIX_TYPE_HUEROTATE: 3;
16450 readonly SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: 4;
16451 isInstance: IsInstance<SVGFEColorMatrixElement>;
16454 interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16455 readonly in1: SVGAnimatedString;
16456 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16457 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16458 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEComponentTransferElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16459 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16462 declare var SVGFEComponentTransferElement: {
16463 prototype: SVGFEComponentTransferElement;
16464 new(): SVGFEComponentTransferElement;
16465 isInstance: IsInstance<SVGFEComponentTransferElement>;
16468 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16469 readonly in1: SVGAnimatedString;
16470 readonly in2: SVGAnimatedString;
16471 readonly k1: SVGAnimatedNumber;
16472 readonly k2: SVGAnimatedNumber;
16473 readonly k3: SVGAnimatedNumber;
16474 readonly k4: SVGAnimatedNumber;
16475 readonly operator: SVGAnimatedEnumeration;
16476 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: 0;
16477 readonly SVG_FECOMPOSITE_OPERATOR_OVER: 1;
16478 readonly SVG_FECOMPOSITE_OPERATOR_IN: 2;
16479 readonly SVG_FECOMPOSITE_OPERATOR_OUT: 3;
16480 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: 4;
16481 readonly SVG_FECOMPOSITE_OPERATOR_XOR: 5;
16482 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: 6;
16483 readonly SVG_FECOMPOSITE_OPERATOR_LIGHTER: 7;
16484 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16485 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16486 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFECompositeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16487 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16490 declare var SVGFECompositeElement: {
16491 prototype: SVGFECompositeElement;
16492 new(): SVGFECompositeElement;
16493 readonly SVG_FECOMPOSITE_OPERATOR_UNKNOWN: 0;
16494 readonly SVG_FECOMPOSITE_OPERATOR_OVER: 1;
16495 readonly SVG_FECOMPOSITE_OPERATOR_IN: 2;
16496 readonly SVG_FECOMPOSITE_OPERATOR_OUT: 3;
16497 readonly SVG_FECOMPOSITE_OPERATOR_ATOP: 4;
16498 readonly SVG_FECOMPOSITE_OPERATOR_XOR: 5;
16499 readonly SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: 6;
16500 readonly SVG_FECOMPOSITE_OPERATOR_LIGHTER: 7;
16501 isInstance: IsInstance<SVGFECompositeElement>;
16504 interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16505 readonly bias: SVGAnimatedNumber;
16506 readonly divisor: SVGAnimatedNumber;
16507 readonly edgeMode: SVGAnimatedEnumeration;
16508 readonly in1: SVGAnimatedString;
16509 readonly kernelMatrix: SVGAnimatedNumberList;
16510 readonly kernelUnitLengthX: SVGAnimatedNumber;
16511 readonly kernelUnitLengthY: SVGAnimatedNumber;
16512 readonly orderX: SVGAnimatedInteger;
16513 readonly orderY: SVGAnimatedInteger;
16514 readonly preserveAlpha: SVGAnimatedBoolean;
16515 readonly targetX: SVGAnimatedInteger;
16516 readonly targetY: SVGAnimatedInteger;
16517 readonly SVG_EDGEMODE_UNKNOWN: 0;
16518 readonly SVG_EDGEMODE_DUPLICATE: 1;
16519 readonly SVG_EDGEMODE_WRAP: 2;
16520 readonly SVG_EDGEMODE_NONE: 3;
16521 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16522 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16523 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEConvolveMatrixElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16524 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16527 declare var SVGFEConvolveMatrixElement: {
16528 prototype: SVGFEConvolveMatrixElement;
16529 new(): SVGFEConvolveMatrixElement;
16530 readonly SVG_EDGEMODE_UNKNOWN: 0;
16531 readonly SVG_EDGEMODE_DUPLICATE: 1;
16532 readonly SVG_EDGEMODE_WRAP: 2;
16533 readonly SVG_EDGEMODE_NONE: 3;
16534 isInstance: IsInstance<SVGFEConvolveMatrixElement>;
16537 interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16538 readonly diffuseConstant: SVGAnimatedNumber;
16539 readonly in1: SVGAnimatedString;
16540 readonly kernelUnitLengthX: SVGAnimatedNumber;
16541 readonly kernelUnitLengthY: SVGAnimatedNumber;
16542 readonly surfaceScale: SVGAnimatedNumber;
16543 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16544 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16545 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDiffuseLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16546 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16549 declare var SVGFEDiffuseLightingElement: {
16550 prototype: SVGFEDiffuseLightingElement;
16551 new(): SVGFEDiffuseLightingElement;
16552 isInstance: IsInstance<SVGFEDiffuseLightingElement>;
16555 interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16556 readonly in1: SVGAnimatedString;
16557 readonly in2: SVGAnimatedString;
16558 readonly scale: SVGAnimatedNumber;
16559 readonly xChannelSelector: SVGAnimatedEnumeration;
16560 readonly yChannelSelector: SVGAnimatedEnumeration;
16561 readonly SVG_CHANNEL_UNKNOWN: 0;
16562 readonly SVG_CHANNEL_R: 1;
16563 readonly SVG_CHANNEL_G: 2;
16564 readonly SVG_CHANNEL_B: 3;
16565 readonly SVG_CHANNEL_A: 4;
16566 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16567 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16568 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDisplacementMapElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16569 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16572 declare var SVGFEDisplacementMapElement: {
16573 prototype: SVGFEDisplacementMapElement;
16574 new(): SVGFEDisplacementMapElement;
16575 readonly SVG_CHANNEL_UNKNOWN: 0;
16576 readonly SVG_CHANNEL_R: 1;
16577 readonly SVG_CHANNEL_G: 2;
16578 readonly SVG_CHANNEL_B: 3;
16579 readonly SVG_CHANNEL_A: 4;
16580 isInstance: IsInstance<SVGFEDisplacementMapElement>;
16583 interface SVGFEDistantLightElement extends SVGElement {
16584 readonly azimuth: SVGAnimatedNumber;
16585 readonly elevation: SVGAnimatedNumber;
16586 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16587 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16588 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDistantLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16589 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16592 declare var SVGFEDistantLightElement: {
16593 prototype: SVGFEDistantLightElement;
16594 new(): SVGFEDistantLightElement;
16595 isInstance: IsInstance<SVGFEDistantLightElement>;
16598 interface SVGFEDropShadowElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16599 readonly dx: SVGAnimatedNumber;
16600 readonly dy: SVGAnimatedNumber;
16601 readonly in1: SVGAnimatedString;
16602 readonly stdDeviationX: SVGAnimatedNumber;
16603 readonly stdDeviationY: SVGAnimatedNumber;
16604 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
16605 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16606 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16607 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEDropShadowElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16608 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16611 declare var SVGFEDropShadowElement: {
16612 prototype: SVGFEDropShadowElement;
16613 new(): SVGFEDropShadowElement;
16614 isInstance: IsInstance<SVGFEDropShadowElement>;
16617 interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16618 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16619 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16620 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFloodElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16621 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16624 declare var SVGFEFloodElement: {
16625 prototype: SVGFEFloodElement;
16626 new(): SVGFEFloodElement;
16627 isInstance: IsInstance<SVGFEFloodElement>;
16630 interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement {
16631 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16632 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16633 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncAElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16634 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16637 declare var SVGFEFuncAElement: {
16638 prototype: SVGFEFuncAElement;
16639 new(): SVGFEFuncAElement;
16640 isInstance: IsInstance<SVGFEFuncAElement>;
16643 interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement {
16644 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16645 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16646 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncBElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16647 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16650 declare var SVGFEFuncBElement: {
16651 prototype: SVGFEFuncBElement;
16652 new(): SVGFEFuncBElement;
16653 isInstance: IsInstance<SVGFEFuncBElement>;
16656 interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement {
16657 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16658 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16659 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16660 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16663 declare var SVGFEFuncGElement: {
16664 prototype: SVGFEFuncGElement;
16665 new(): SVGFEFuncGElement;
16666 isInstance: IsInstance<SVGFEFuncGElement>;
16669 interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement {
16670 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16671 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16672 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEFuncRElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16673 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16676 declare var SVGFEFuncRElement: {
16677 prototype: SVGFEFuncRElement;
16678 new(): SVGFEFuncRElement;
16679 isInstance: IsInstance<SVGFEFuncRElement>;
16682 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16683 readonly in1: SVGAnimatedString;
16684 readonly stdDeviationX: SVGAnimatedNumber;
16685 readonly stdDeviationY: SVGAnimatedNumber;
16686 setStdDeviation(stdDeviationX: number, stdDeviationY: number): void;
16687 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16688 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16689 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEGaussianBlurElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16690 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16693 declare var SVGFEGaussianBlurElement: {
16694 prototype: SVGFEGaussianBlurElement;
16695 new(): SVGFEGaussianBlurElement;
16696 isInstance: IsInstance<SVGFEGaussianBlurElement>;
16699 interface SVGFEImageElement extends SVGElement, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
16700 crossOrigin: string | null;
16701 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
16702 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16703 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16704 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16705 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16708 declare var SVGFEImageElement: {
16709 prototype: SVGFEImageElement;
16710 new(): SVGFEImageElement;
16711 isInstance: IsInstance<SVGFEImageElement>;
16714 interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16715 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16716 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16717 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16718 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16721 declare var SVGFEMergeElement: {
16722 prototype: SVGFEMergeElement;
16723 new(): SVGFEMergeElement;
16724 isInstance: IsInstance<SVGFEMergeElement>;
16727 interface SVGFEMergeNodeElement extends SVGElement {
16728 readonly in1: SVGAnimatedString;
16729 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16730 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16731 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMergeNodeElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16732 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16735 declare var SVGFEMergeNodeElement: {
16736 prototype: SVGFEMergeNodeElement;
16737 new(): SVGFEMergeNodeElement;
16738 isInstance: IsInstance<SVGFEMergeNodeElement>;
16741 interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16742 readonly in1: SVGAnimatedString;
16743 readonly operator: SVGAnimatedEnumeration;
16744 readonly radiusX: SVGAnimatedNumber;
16745 readonly radiusY: SVGAnimatedNumber;
16746 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: 0;
16747 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: 1;
16748 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: 2;
16749 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16750 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16751 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEMorphologyElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16752 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16755 declare var SVGFEMorphologyElement: {
16756 prototype: SVGFEMorphologyElement;
16757 new(): SVGFEMorphologyElement;
16758 readonly SVG_MORPHOLOGY_OPERATOR_UNKNOWN: 0;
16759 readonly SVG_MORPHOLOGY_OPERATOR_ERODE: 1;
16760 readonly SVG_MORPHOLOGY_OPERATOR_DILATE: 2;
16761 isInstance: IsInstance<SVGFEMorphologyElement>;
16764 interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16765 readonly dx: SVGAnimatedNumber;
16766 readonly dy: SVGAnimatedNumber;
16767 readonly in1: SVGAnimatedString;
16768 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16769 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16770 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEOffsetElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16771 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16774 declare var SVGFEOffsetElement: {
16775 prototype: SVGFEOffsetElement;
16776 new(): SVGFEOffsetElement;
16777 isInstance: IsInstance<SVGFEOffsetElement>;
16780 interface SVGFEPointLightElement extends SVGElement {
16781 readonly x: SVGAnimatedNumber;
16782 readonly y: SVGAnimatedNumber;
16783 readonly z: SVGAnimatedNumber;
16784 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16785 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16786 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFEPointLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16787 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16790 declare var SVGFEPointLightElement: {
16791 prototype: SVGFEPointLightElement;
16792 new(): SVGFEPointLightElement;
16793 isInstance: IsInstance<SVGFEPointLightElement>;
16796 interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16797 readonly in1: SVGAnimatedString;
16798 readonly kernelUnitLengthX: SVGAnimatedNumber;
16799 readonly kernelUnitLengthY: SVGAnimatedNumber;
16800 readonly specularConstant: SVGAnimatedNumber;
16801 readonly specularExponent: SVGAnimatedNumber;
16802 readonly surfaceScale: SVGAnimatedNumber;
16803 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16804 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16805 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpecularLightingElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16806 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16809 declare var SVGFESpecularLightingElement: {
16810 prototype: SVGFESpecularLightingElement;
16811 new(): SVGFESpecularLightingElement;
16812 isInstance: IsInstance<SVGFESpecularLightingElement>;
16815 interface SVGFESpotLightElement extends SVGElement {
16816 readonly limitingConeAngle: SVGAnimatedNumber;
16817 readonly pointsAtX: SVGAnimatedNumber;
16818 readonly pointsAtY: SVGAnimatedNumber;
16819 readonly pointsAtZ: SVGAnimatedNumber;
16820 readonly specularExponent: SVGAnimatedNumber;
16821 readonly x: SVGAnimatedNumber;
16822 readonly y: SVGAnimatedNumber;
16823 readonly z: SVGAnimatedNumber;
16824 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16825 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16826 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFESpotLightElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16827 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16830 declare var SVGFESpotLightElement: {
16831 prototype: SVGFESpotLightElement;
16832 new(): SVGFESpotLightElement;
16833 isInstance: IsInstance<SVGFESpotLightElement>;
16836 interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16837 readonly in1: SVGAnimatedString;
16838 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16839 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16840 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETileElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16841 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16844 declare var SVGFETileElement: {
16845 prototype: SVGFETileElement;
16846 new(): SVGFETileElement;
16847 isInstance: IsInstance<SVGFETileElement>;
16850 interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
16851 readonly baseFrequencyX: SVGAnimatedNumber;
16852 readonly baseFrequencyY: SVGAnimatedNumber;
16853 readonly numOctaves: SVGAnimatedInteger;
16854 readonly seed: SVGAnimatedNumber;
16855 readonly stitchTiles: SVGAnimatedEnumeration;
16856 readonly type: SVGAnimatedEnumeration;
16857 readonly SVG_TURBULENCE_TYPE_UNKNOWN: 0;
16858 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: 1;
16859 readonly SVG_TURBULENCE_TYPE_TURBULENCE: 2;
16860 readonly SVG_STITCHTYPE_UNKNOWN: 0;
16861 readonly SVG_STITCHTYPE_STITCH: 1;
16862 readonly SVG_STITCHTYPE_NOSTITCH: 2;
16863 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16864 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16865 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFETurbulenceElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16866 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16869 declare var SVGFETurbulenceElement: {
16870 prototype: SVGFETurbulenceElement;
16871 new(): SVGFETurbulenceElement;
16872 readonly SVG_TURBULENCE_TYPE_UNKNOWN: 0;
16873 readonly SVG_TURBULENCE_TYPE_FRACTALNOISE: 1;
16874 readonly SVG_TURBULENCE_TYPE_TURBULENCE: 2;
16875 readonly SVG_STITCHTYPE_UNKNOWN: 0;
16876 readonly SVG_STITCHTYPE_STITCH: 1;
16877 readonly SVG_STITCHTYPE_NOSTITCH: 2;
16878 isInstance: IsInstance<SVGFETurbulenceElement>;
16881 interface SVGFilterElement extends SVGElement, SVGURIReference {
16882 readonly filterUnits: SVGAnimatedEnumeration;
16883 readonly height: SVGAnimatedLength;
16884 readonly primitiveUnits: SVGAnimatedEnumeration;
16885 readonly width: SVGAnimatedLength;
16886 readonly x: SVGAnimatedLength;
16887 readonly y: SVGAnimatedLength;
16888 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16889 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16890 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGFilterElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16891 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16894 declare var SVGFilterElement: {
16895 prototype: SVGFilterElement;
16896 new(): SVGFilterElement;
16897 isInstance: IsInstance<SVGFilterElement>;
16900 interface SVGFilterPrimitiveStandardAttributes {
16901 readonly height: SVGAnimatedLength;
16902 readonly result: SVGAnimatedString;
16903 readonly width: SVGAnimatedLength;
16904 readonly x: SVGAnimatedLength;
16905 readonly y: SVGAnimatedLength;
16908 interface SVGFitToViewBox {
16909 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
16910 readonly viewBox: SVGAnimatedRect;
16913 interface SVGForeignObjectElement extends SVGGraphicsElement {
16914 readonly height: SVGAnimatedLength;
16915 readonly width: SVGAnimatedLength;
16916 readonly x: SVGAnimatedLength;
16917 readonly y: SVGAnimatedLength;
16918 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16919 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16920 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGForeignObjectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16921 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16924 declare var SVGForeignObjectElement: {
16925 prototype: SVGForeignObjectElement;
16926 new(): SVGForeignObjectElement;
16927 isInstance: IsInstance<SVGForeignObjectElement>;
16930 interface SVGGElement extends SVGGraphicsElement {
16931 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16932 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16933 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16934 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16937 declare var SVGGElement: {
16938 prototype: SVGGElement;
16939 new(): SVGGElement;
16940 isInstance: IsInstance<SVGGElement>;
16943 interface SVGGeometryElement extends SVGGraphicsElement {
16944 readonly pathLength: SVGAnimatedNumber;
16945 getPointAtLength(distance: number): SVGPoint;
16946 getTotalLength(): number;
16947 isPointInFill(point?: DOMPointInit): boolean;
16948 isPointInStroke(point?: DOMPointInit): boolean;
16949 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16950 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16951 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGeometryElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16952 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16955 declare var SVGGeometryElement: {
16956 prototype: SVGGeometryElement;
16957 new(): SVGGeometryElement;
16958 isInstance: IsInstance<SVGGeometryElement>;
16961 interface SVGGradientElement extends SVGElement, SVGURIReference {
16962 readonly gradientTransform: SVGAnimatedTransformList;
16963 readonly gradientUnits: SVGAnimatedEnumeration;
16964 readonly spreadMethod: SVGAnimatedEnumeration;
16965 readonly SVG_SPREADMETHOD_UNKNOWN: 0;
16966 readonly SVG_SPREADMETHOD_PAD: 1;
16967 readonly SVG_SPREADMETHOD_REFLECT: 2;
16968 readonly SVG_SPREADMETHOD_REPEAT: 3;
16969 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16970 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16971 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16972 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16975 declare var SVGGradientElement: {
16976 prototype: SVGGradientElement;
16977 new(): SVGGradientElement;
16978 readonly SVG_SPREADMETHOD_UNKNOWN: 0;
16979 readonly SVG_SPREADMETHOD_PAD: 1;
16980 readonly SVG_SPREADMETHOD_REFLECT: 2;
16981 readonly SVG_SPREADMETHOD_REPEAT: 3;
16982 isInstance: IsInstance<SVGGradientElement>;
16985 interface SVGGraphicsElement extends SVGElement, SVGTests {
16986 readonly farthestViewportElement: SVGElement | null;
16987 readonly nearestViewportElement: SVGElement | null;
16988 readonly transform: SVGAnimatedTransformList;
16989 getBBox(aOptions?: SVGBoundingBoxOptions): SVGRect;
16990 getCTM(): SVGMatrix | null;
16991 getScreenCTM(): SVGMatrix | null;
16992 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
16993 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
16994 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGGraphicsElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
16995 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
16998 declare var SVGGraphicsElement: {
16999 prototype: SVGGraphicsElement;
17000 new(): SVGGraphicsElement;
17001 isInstance: IsInstance<SVGGraphicsElement>;
17004 interface SVGImageElement extends SVGGraphicsElement, MozImageLoadingContent, SVGURIReference {
17005 crossOrigin: string | null;
17007 readonly height: SVGAnimatedLength;
17008 readonly preserveAspectRatio: SVGAnimatedPreserveAspectRatio;
17009 readonly width: SVGAnimatedLength;
17010 readonly x: SVGAnimatedLength;
17011 readonly y: SVGAnimatedLength;
17012 decode(): Promise<void>;
17013 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17014 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17015 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGImageElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17016 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17019 declare var SVGImageElement: {
17020 prototype: SVGImageElement;
17021 new(): SVGImageElement;
17022 readonly UNKNOWN_REQUEST: -1;
17023 readonly CURRENT_REQUEST: 0;
17024 readonly PENDING_REQUEST: 1;
17025 isInstance: IsInstance<SVGImageElement>;
17028 interface SVGLength {
17029 readonly unitType: number;
17031 valueAsString: string;
17032 valueInSpecifiedUnits: number;
17033 convertToSpecifiedUnits(unitType: number): void;
17034 newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void;
17035 readonly SVG_LENGTHTYPE_UNKNOWN: 0;
17036 readonly SVG_LENGTHTYPE_NUMBER: 1;
17037 readonly SVG_LENGTHTYPE_PERCENTAGE: 2;
17038 readonly SVG_LENGTHTYPE_EMS: 3;
17039 readonly SVG_LENGTHTYPE_EXS: 4;
17040 readonly SVG_LENGTHTYPE_PX: 5;
17041 readonly SVG_LENGTHTYPE_CM: 6;
17042 readonly SVG_LENGTHTYPE_MM: 7;
17043 readonly SVG_LENGTHTYPE_IN: 8;
17044 readonly SVG_LENGTHTYPE_PT: 9;
17045 readonly SVG_LENGTHTYPE_PC: 10;
17048 declare var SVGLength: {
17049 prototype: SVGLength;
17051 readonly SVG_LENGTHTYPE_UNKNOWN: 0;
17052 readonly SVG_LENGTHTYPE_NUMBER: 1;
17053 readonly SVG_LENGTHTYPE_PERCENTAGE: 2;
17054 readonly SVG_LENGTHTYPE_EMS: 3;
17055 readonly SVG_LENGTHTYPE_EXS: 4;
17056 readonly SVG_LENGTHTYPE_PX: 5;
17057 readonly SVG_LENGTHTYPE_CM: 6;
17058 readonly SVG_LENGTHTYPE_MM: 7;
17059 readonly SVG_LENGTHTYPE_IN: 8;
17060 readonly SVG_LENGTHTYPE_PT: 9;
17061 readonly SVG_LENGTHTYPE_PC: 10;
17062 isInstance: IsInstance<SVGLength>;
17065 interface SVGLengthList {
17066 readonly length: number;
17067 readonly numberOfItems: number;
17068 appendItem(newItem: SVGLength): SVGLength;
17070 getItem(index: number): SVGLength;
17071 initialize(newItem: SVGLength): SVGLength;
17072 insertItemBefore(newItem: SVGLength, index: number): SVGLength;
17073 removeItem(index: number): SVGLength;
17074 replaceItem(newItem: SVGLength, index: number): SVGLength;
17075 [index: number]: SVGLength;
17078 declare var SVGLengthList: {
17079 prototype: SVGLengthList;
17080 new(): SVGLengthList;
17081 isInstance: IsInstance<SVGLengthList>;
17084 interface SVGLineElement extends SVGGeometryElement {
17085 readonly x1: SVGAnimatedLength;
17086 readonly x2: SVGAnimatedLength;
17087 readonly y1: SVGAnimatedLength;
17088 readonly y2: SVGAnimatedLength;
17089 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17090 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17091 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17092 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17095 declare var SVGLineElement: {
17096 prototype: SVGLineElement;
17097 new(): SVGLineElement;
17098 isInstance: IsInstance<SVGLineElement>;
17101 interface SVGLinearGradientElement extends SVGGradientElement {
17102 readonly x1: SVGAnimatedLength;
17103 readonly x2: SVGAnimatedLength;
17104 readonly y1: SVGAnimatedLength;
17105 readonly y2: SVGAnimatedLength;
17106 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17107 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17108 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGLinearGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17109 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17112 declare var SVGLinearGradientElement: {
17113 prototype: SVGLinearGradientElement;
17114 new(): SVGLinearGradientElement;
17115 isInstance: IsInstance<SVGLinearGradientElement>;
17118 interface SVGMPathElement extends SVGElement, SVGURIReference {
17119 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17120 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17121 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17122 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17125 declare var SVGMPathElement: {
17126 prototype: SVGMPathElement;
17127 new(): SVGMPathElement;
17128 isInstance: IsInstance<SVGMPathElement>;
17131 interface SVGMarkerElement extends SVGElement, SVGFitToViewBox {
17132 readonly markerHeight: SVGAnimatedLength;
17133 readonly markerUnits: SVGAnimatedEnumeration;
17134 readonly markerWidth: SVGAnimatedLength;
17135 readonly orientAngle: SVGAnimatedAngle;
17136 readonly orientType: SVGAnimatedEnumeration;
17137 readonly refX: SVGAnimatedLength;
17138 readonly refY: SVGAnimatedLength;
17139 setOrientToAngle(angle: SVGAngle): void;
17140 setOrientToAuto(): void;
17141 readonly SVG_MARKERUNITS_UNKNOWN: 0;
17142 readonly SVG_MARKERUNITS_USERSPACEONUSE: 1;
17143 readonly SVG_MARKERUNITS_STROKEWIDTH: 2;
17144 readonly SVG_MARKER_ORIENT_UNKNOWN: 0;
17145 readonly SVG_MARKER_ORIENT_AUTO: 1;
17146 readonly SVG_MARKER_ORIENT_ANGLE: 2;
17147 readonly SVG_MARKER_ORIENT_AUTO_START_REVERSE: 3;
17148 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17149 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17150 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMarkerElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17151 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17154 declare var SVGMarkerElement: {
17155 prototype: SVGMarkerElement;
17156 new(): SVGMarkerElement;
17157 readonly SVG_MARKERUNITS_UNKNOWN: 0;
17158 readonly SVG_MARKERUNITS_USERSPACEONUSE: 1;
17159 readonly SVG_MARKERUNITS_STROKEWIDTH: 2;
17160 readonly SVG_MARKER_ORIENT_UNKNOWN: 0;
17161 readonly SVG_MARKER_ORIENT_AUTO: 1;
17162 readonly SVG_MARKER_ORIENT_ANGLE: 2;
17163 readonly SVG_MARKER_ORIENT_AUTO_START_REVERSE: 3;
17164 isInstance: IsInstance<SVGMarkerElement>;
17167 interface SVGMaskElement extends SVGElement {
17168 readonly height: SVGAnimatedLength;
17169 readonly maskContentUnits: SVGAnimatedEnumeration;
17170 readonly maskUnits: SVGAnimatedEnumeration;
17171 readonly width: SVGAnimatedLength;
17172 readonly x: SVGAnimatedLength;
17173 readonly y: SVGAnimatedLength;
17174 readonly SVG_MASKTYPE_LUMINANCE: 0;
17175 readonly SVG_MASKTYPE_ALPHA: 1;
17176 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17177 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17178 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMaskElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17179 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17182 declare var SVGMaskElement: {
17183 prototype: SVGMaskElement;
17184 new(): SVGMaskElement;
17185 readonly SVG_MASKTYPE_LUMINANCE: 0;
17186 readonly SVG_MASKTYPE_ALPHA: 1;
17187 isInstance: IsInstance<SVGMaskElement>;
17190 interface SVGMatrix {
17197 flipX(): SVGMatrix;
17198 flipY(): SVGMatrix;
17199 inverse(): SVGMatrix;
17200 multiply(secondMatrix: SVGMatrix): SVGMatrix;
17201 rotate(angle: number): SVGMatrix;
17202 rotateFromVector(x: number, y: number): SVGMatrix;
17203 scale(scaleFactor: number): SVGMatrix;
17204 scaleNonUniform(scaleFactorX: number, scaleFactorY: number): SVGMatrix;
17205 skewX(angle: number): SVGMatrix;
17206 skewY(angle: number): SVGMatrix;
17207 translate(x: number, y: number): SVGMatrix;
17210 declare var SVGMatrix: {
17211 prototype: SVGMatrix;
17213 isInstance: IsInstance<SVGMatrix>;
17216 interface SVGMetadataElement extends SVGElement {
17217 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17218 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17219 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGMetadataElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17220 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17223 declare var SVGMetadataElement: {
17224 prototype: SVGMetadataElement;
17225 new(): SVGMetadataElement;
17226 isInstance: IsInstance<SVGMetadataElement>;
17229 interface SVGNumber {
17233 declare var SVGNumber: {
17234 prototype: SVGNumber;
17236 isInstance: IsInstance<SVGNumber>;
17239 interface SVGNumberList {
17240 readonly length: number;
17241 readonly numberOfItems: number;
17242 appendItem(newItem: SVGNumber): SVGNumber;
17244 getItem(index: number): SVGNumber;
17245 initialize(newItem: SVGNumber): SVGNumber;
17246 insertItemBefore(newItem: SVGNumber, index: number): SVGNumber;
17247 removeItem(index: number): SVGNumber;
17248 replaceItem(newItem: SVGNumber, index: number): SVGNumber;
17249 [index: number]: SVGNumber;
17252 declare var SVGNumberList: {
17253 prototype: SVGNumberList;
17254 new(): SVGNumberList;
17255 isInstance: IsInstance<SVGNumberList>;
17258 interface SVGPathElement extends SVGGeometryElement, SVGAnimatedPathData {
17259 getPathSegAtLength(distance: number): number;
17260 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17261 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17262 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17263 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17266 declare var SVGPathElement: {
17267 prototype: SVGPathElement;
17268 new(): SVGPathElement;
17269 isInstance: IsInstance<SVGPathElement>;
17272 interface SVGPathSeg {
17273 readonly pathSegType: number;
17274 readonly pathSegTypeAsLetter: string;
17275 readonly PATHSEG_UNKNOWN: 0;
17276 readonly PATHSEG_CLOSEPATH: 1;
17277 readonly PATHSEG_MOVETO_ABS: 2;
17278 readonly PATHSEG_MOVETO_REL: 3;
17279 readonly PATHSEG_LINETO_ABS: 4;
17280 readonly PATHSEG_LINETO_REL: 5;
17281 readonly PATHSEG_CURVETO_CUBIC_ABS: 6;
17282 readonly PATHSEG_CURVETO_CUBIC_REL: 7;
17283 readonly PATHSEG_CURVETO_QUADRATIC_ABS: 8;
17284 readonly PATHSEG_CURVETO_QUADRATIC_REL: 9;
17285 readonly PATHSEG_ARC_ABS: 10;
17286 readonly PATHSEG_ARC_REL: 11;
17287 readonly PATHSEG_LINETO_HORIZONTAL_ABS: 12;
17288 readonly PATHSEG_LINETO_HORIZONTAL_REL: 13;
17289 readonly PATHSEG_LINETO_VERTICAL_ABS: 14;
17290 readonly PATHSEG_LINETO_VERTICAL_REL: 15;
17291 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: 16;
17292 readonly PATHSEG_CURVETO_CUBIC_SMOOTH_REL: 17;
17293 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: 18;
17294 readonly PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: 19;
17297 interface SVGPathSegArcAbs extends SVGPathSeg {
17299 largeArcFlag: boolean;
17302 sweepFlag: boolean;
17307 interface SVGPathSegArcRel extends SVGPathSeg {
17309 largeArcFlag: boolean;
17312 sweepFlag: boolean;
17317 interface SVGPathSegClosePath extends SVGPathSeg {
17320 interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg {
17329 interface SVGPathSegCurvetoCubicRel extends SVGPathSeg {
17338 interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {
17345 interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {
17352 interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {
17359 interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
17366 interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {
17371 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
17376 interface SVGPathSegLinetoAbs extends SVGPathSeg {
17381 interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {
17385 interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg {
17389 interface SVGPathSegLinetoRel extends SVGPathSeg {
17394 interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg {
17398 interface SVGPathSegLinetoVerticalRel extends SVGPathSeg {
17402 interface SVGPathSegList {
17403 readonly length: number;
17404 readonly numberOfItems: number;
17405 getItem(index: number): SVGPathSeg;
17406 [index: number]: SVGPathSeg;
17409 declare var SVGPathSegList: {
17410 prototype: SVGPathSegList;
17411 new(): SVGPathSegList;
17412 isInstance: IsInstance<SVGPathSegList>;
17415 interface SVGPathSegMovetoAbs extends SVGPathSeg {
17420 interface SVGPathSegMovetoRel extends SVGPathSeg {
17425 interface SVGPatternElement extends SVGElement, SVGFitToViewBox, SVGURIReference {
17426 readonly height: SVGAnimatedLength;
17427 readonly patternContentUnits: SVGAnimatedEnumeration;
17428 readonly patternTransform: SVGAnimatedTransformList;
17429 readonly patternUnits: SVGAnimatedEnumeration;
17430 readonly width: SVGAnimatedLength;
17431 readonly x: SVGAnimatedLength;
17432 readonly y: SVGAnimatedLength;
17433 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17434 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17435 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPatternElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17436 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17439 declare var SVGPatternElement: {
17440 prototype: SVGPatternElement;
17441 new(): SVGPatternElement;
17442 isInstance: IsInstance<SVGPatternElement>;
17445 interface SVGPoint {
17448 matrixTransform(matrix?: DOMMatrix2DInit): SVGPoint;
17451 declare var SVGPoint: {
17452 prototype: SVGPoint;
17454 isInstance: IsInstance<SVGPoint>;
17457 interface SVGPointList {
17458 readonly length: number;
17459 readonly numberOfItems: number;
17460 appendItem(newItem: SVGPoint): SVGPoint;
17462 getItem(index: number): SVGPoint;
17463 initialize(newItem: SVGPoint): SVGPoint;
17464 insertItemBefore(newItem: SVGPoint, index: number): SVGPoint;
17465 removeItem(index: number): SVGPoint;
17466 replaceItem(newItem: SVGPoint, index: number): SVGPoint;
17467 [index: number]: SVGPoint;
17470 declare var SVGPointList: {
17471 prototype: SVGPointList;
17472 new(): SVGPointList;
17473 isInstance: IsInstance<SVGPointList>;
17476 interface SVGPolygonElement extends SVGGeometryElement, SVGAnimatedPoints {
17477 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17478 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17479 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolygonElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17480 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17483 declare var SVGPolygonElement: {
17484 prototype: SVGPolygonElement;
17485 new(): SVGPolygonElement;
17486 isInstance: IsInstance<SVGPolygonElement>;
17489 interface SVGPolylineElement extends SVGGeometryElement, SVGAnimatedPoints {
17490 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17491 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17492 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGPolylineElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17493 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17496 declare var SVGPolylineElement: {
17497 prototype: SVGPolylineElement;
17498 new(): SVGPolylineElement;
17499 isInstance: IsInstance<SVGPolylineElement>;
17502 interface SVGPreserveAspectRatio {
17504 meetOrSlice: number;
17505 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: 0;
17506 readonly SVG_PRESERVEASPECTRATIO_NONE: 1;
17507 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: 2;
17508 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: 3;
17509 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: 4;
17510 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: 5;
17511 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: 6;
17512 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: 7;
17513 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: 8;
17514 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: 9;
17515 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: 10;
17516 readonly SVG_MEETORSLICE_UNKNOWN: 0;
17517 readonly SVG_MEETORSLICE_MEET: 1;
17518 readonly SVG_MEETORSLICE_SLICE: 2;
17521 declare var SVGPreserveAspectRatio: {
17522 prototype: SVGPreserveAspectRatio;
17523 new(): SVGPreserveAspectRatio;
17524 readonly SVG_PRESERVEASPECTRATIO_UNKNOWN: 0;
17525 readonly SVG_PRESERVEASPECTRATIO_NONE: 1;
17526 readonly SVG_PRESERVEASPECTRATIO_XMINYMIN: 2;
17527 readonly SVG_PRESERVEASPECTRATIO_XMIDYMIN: 3;
17528 readonly SVG_PRESERVEASPECTRATIO_XMAXYMIN: 4;
17529 readonly SVG_PRESERVEASPECTRATIO_XMINYMID: 5;
17530 readonly SVG_PRESERVEASPECTRATIO_XMIDYMID: 6;
17531 readonly SVG_PRESERVEASPECTRATIO_XMAXYMID: 7;
17532 readonly SVG_PRESERVEASPECTRATIO_XMINYMAX: 8;
17533 readonly SVG_PRESERVEASPECTRATIO_XMIDYMAX: 9;
17534 readonly SVG_PRESERVEASPECTRATIO_XMAXYMAX: 10;
17535 readonly SVG_MEETORSLICE_UNKNOWN: 0;
17536 readonly SVG_MEETORSLICE_MEET: 1;
17537 readonly SVG_MEETORSLICE_SLICE: 2;
17538 isInstance: IsInstance<SVGPreserveAspectRatio>;
17541 interface SVGRadialGradientElement extends SVGGradientElement {
17542 readonly cx: SVGAnimatedLength;
17543 readonly cy: SVGAnimatedLength;
17544 readonly fr: SVGAnimatedLength;
17545 readonly fx: SVGAnimatedLength;
17546 readonly fy: SVGAnimatedLength;
17547 readonly r: SVGAnimatedLength;
17548 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17549 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17550 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRadialGradientElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17551 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17554 declare var SVGRadialGradientElement: {
17555 prototype: SVGRadialGradientElement;
17556 new(): SVGRadialGradientElement;
17557 isInstance: IsInstance<SVGRadialGradientElement>;
17560 interface SVGRect {
17567 declare var SVGRect: {
17568 prototype: SVGRect;
17570 isInstance: IsInstance<SVGRect>;
17573 interface SVGRectElement extends SVGGeometryElement {
17574 readonly height: SVGAnimatedLength;
17575 readonly rx: SVGAnimatedLength;
17576 readonly ry: SVGAnimatedLength;
17577 readonly width: SVGAnimatedLength;
17578 readonly x: SVGAnimatedLength;
17579 readonly y: SVGAnimatedLength;
17580 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17581 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17582 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGRectElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17583 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17586 declare var SVGRectElement: {
17587 prototype: SVGRectElement;
17588 new(): SVGRectElement;
17589 isInstance: IsInstance<SVGRectElement>;
17592 interface SVGSVGElement extends SVGGraphicsElement, SVGFitToViewBox, SVGZoomAndPan {
17593 currentScale: number;
17594 readonly currentTranslate: SVGPoint;
17595 readonly height: SVGAnimatedLength;
17596 readonly width: SVGAnimatedLength;
17597 readonly x: SVGAnimatedLength;
17598 readonly y: SVGAnimatedLength;
17599 animationsPaused(): boolean;
17600 createSVGAngle(): SVGAngle;
17601 createSVGLength(): SVGLength;
17602 createSVGMatrix(): SVGMatrix;
17603 createSVGNumber(): SVGNumber;
17604 createSVGPoint(): SVGPoint;
17605 createSVGRect(): SVGRect;
17606 createSVGTransform(): SVGTransform;
17607 createSVGTransformFromMatrix(matrix?: DOMMatrix2DInit): SVGTransform;
17608 deselectAll(): void;
17609 forceRedraw(): void;
17610 getCurrentTime(): number;
17611 getElementById(elementId: string): Element | null;
17612 pauseAnimations(): void;
17613 setCurrentTime(seconds: number): void;
17614 suspendRedraw(maxWaitMilliseconds: number): number;
17615 unpauseAnimations(): void;
17616 unsuspendRedraw(suspendHandleID: number): void;
17617 unsuspendRedrawAll(): void;
17618 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17619 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17620 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSVGElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17621 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17624 declare var SVGSVGElement: {
17625 prototype: SVGSVGElement;
17626 new(): SVGSVGElement;
17627 readonly SVG_ZOOMANDPAN_UNKNOWN: 0;
17628 readonly SVG_ZOOMANDPAN_DISABLE: 1;
17629 readonly SVG_ZOOMANDPAN_MAGNIFY: 2;
17630 isInstance: IsInstance<SVGSVGElement>;
17633 interface SVGScriptElement extends SVGElement, SVGURIReference {
17635 crossOrigin: string | null;
17638 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17639 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17640 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGScriptElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17641 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17644 declare var SVGScriptElement: {
17645 prototype: SVGScriptElement;
17646 new(): SVGScriptElement;
17647 isInstance: IsInstance<SVGScriptElement>;
17650 interface SVGSetElement extends SVGAnimationElement {
17651 addEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGSetElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17652 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17653 removeEventListener<K extends keyof SVGAnimationElementEventMap>(type: K, listener: (this: SVGSetElement, ev: SVGAnimationElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17654 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17657 declare var SVGSetElement: {
17658 prototype: SVGSetElement;
17659 new(): SVGSetElement;
17660 isInstance: IsInstance<SVGSetElement>;
17663 interface SVGStopElement extends SVGElement {
17664 readonly offset: SVGAnimatedNumber;
17665 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17666 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17667 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStopElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17668 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17671 declare var SVGStopElement: {
17672 prototype: SVGStopElement;
17673 new(): SVGStopElement;
17674 isInstance: IsInstance<SVGStopElement>;
17677 interface SVGStringList {
17678 readonly length: number;
17679 readonly numberOfItems: number;
17680 appendItem(newItem: string): string;
17682 getItem(index: number): string;
17683 initialize(newItem: string): string;
17684 insertItemBefore(newItem: string, index: number): string;
17685 removeItem(index: number): string;
17686 replaceItem(newItem: string, index: number): string;
17687 [index: number]: string;
17690 declare var SVGStringList: {
17691 prototype: SVGStringList;
17692 new(): SVGStringList;
17693 isInstance: IsInstance<SVGStringList>;
17696 interface SVGStyleElement extends SVGElement, LinkStyle {
17701 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17702 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17703 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGStyleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17704 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17707 declare var SVGStyleElement: {
17708 prototype: SVGStyleElement;
17709 new(): SVGStyleElement;
17710 isInstance: IsInstance<SVGStyleElement>;
17713 interface SVGSwitchElement extends SVGGraphicsElement {
17714 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17715 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17716 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSwitchElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17717 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17720 declare var SVGSwitchElement: {
17721 prototype: SVGSwitchElement;
17722 new(): SVGSwitchElement;
17723 isInstance: IsInstance<SVGSwitchElement>;
17726 interface SVGSymbolElement extends SVGElement, SVGFitToViewBox, SVGTests {
17727 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17728 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17729 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGSymbolElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17730 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17733 declare var SVGSymbolElement: {
17734 prototype: SVGSymbolElement;
17735 new(): SVGSymbolElement;
17736 isInstance: IsInstance<SVGSymbolElement>;
17739 interface SVGTSpanElement extends SVGTextPositioningElement {
17740 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17741 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17742 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTSpanElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17743 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17746 declare var SVGTSpanElement: {
17747 prototype: SVGTSpanElement;
17748 new(): SVGTSpanElement;
17749 isInstance: IsInstance<SVGTSpanElement>;
17752 interface SVGTests {
17753 readonly requiredExtensions: SVGStringList;
17754 readonly systemLanguage: SVGStringList;
17757 interface SVGTextContentElement extends SVGGraphicsElement {
17758 readonly lengthAdjust: SVGAnimatedEnumeration;
17759 readonly textLength: SVGAnimatedLength;
17760 getCharNumAtPosition(point?: DOMPointInit): number;
17761 getComputedTextLength(): number;
17762 getEndPositionOfChar(charnum: number): SVGPoint;
17763 getExtentOfChar(charnum: number): SVGRect;
17764 getNumberOfChars(): number;
17765 getRotationOfChar(charnum: number): number;
17766 getStartPositionOfChar(charnum: number): SVGPoint;
17767 getSubStringLength(charnum: number, nchars: number): number;
17768 selectSubString(charnum: number, nchars: number): void;
17769 readonly LENGTHADJUST_UNKNOWN: 0;
17770 readonly LENGTHADJUST_SPACING: 1;
17771 readonly LENGTHADJUST_SPACINGANDGLYPHS: 2;
17772 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17773 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17774 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextContentElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17775 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17778 declare var SVGTextContentElement: {
17779 prototype: SVGTextContentElement;
17780 new(): SVGTextContentElement;
17781 readonly LENGTHADJUST_UNKNOWN: 0;
17782 readonly LENGTHADJUST_SPACING: 1;
17783 readonly LENGTHADJUST_SPACINGANDGLYPHS: 2;
17784 isInstance: IsInstance<SVGTextContentElement>;
17787 interface SVGTextElement extends SVGTextPositioningElement {
17788 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17789 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17790 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17791 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17794 declare var SVGTextElement: {
17795 prototype: SVGTextElement;
17796 new(): SVGTextElement;
17797 isInstance: IsInstance<SVGTextElement>;
17800 interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference {
17801 readonly method: SVGAnimatedEnumeration;
17802 readonly spacing: SVGAnimatedEnumeration;
17803 readonly startOffset: SVGAnimatedLength;
17804 readonly TEXTPATH_METHODTYPE_UNKNOWN: 0;
17805 readonly TEXTPATH_METHODTYPE_ALIGN: 1;
17806 readonly TEXTPATH_METHODTYPE_STRETCH: 2;
17807 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: 0;
17808 readonly TEXTPATH_SPACINGTYPE_AUTO: 1;
17809 readonly TEXTPATH_SPACINGTYPE_EXACT: 2;
17810 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17811 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17812 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPathElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17813 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17816 declare var SVGTextPathElement: {
17817 prototype: SVGTextPathElement;
17818 new(): SVGTextPathElement;
17819 readonly TEXTPATH_METHODTYPE_UNKNOWN: 0;
17820 readonly TEXTPATH_METHODTYPE_ALIGN: 1;
17821 readonly TEXTPATH_METHODTYPE_STRETCH: 2;
17822 readonly TEXTPATH_SPACINGTYPE_UNKNOWN: 0;
17823 readonly TEXTPATH_SPACINGTYPE_AUTO: 1;
17824 readonly TEXTPATH_SPACINGTYPE_EXACT: 2;
17825 isInstance: IsInstance<SVGTextPathElement>;
17828 interface SVGTextPositioningElement extends SVGTextContentElement {
17829 readonly dx: SVGAnimatedLengthList;
17830 readonly dy: SVGAnimatedLengthList;
17831 readonly rotate: SVGAnimatedNumberList;
17832 readonly x: SVGAnimatedLengthList;
17833 readonly y: SVGAnimatedLengthList;
17834 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17835 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17836 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTextPositioningElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17837 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17840 declare var SVGTextPositioningElement: {
17841 prototype: SVGTextPositioningElement;
17842 new(): SVGTextPositioningElement;
17843 isInstance: IsInstance<SVGTextPositioningElement>;
17846 interface SVGTitleElement extends SVGElement {
17847 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17848 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17849 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGTitleElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17850 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17853 declare var SVGTitleElement: {
17854 prototype: SVGTitleElement;
17855 new(): SVGTitleElement;
17856 isInstance: IsInstance<SVGTitleElement>;
17859 interface SVGTransform {
17860 readonly angle: number;
17861 readonly matrix: SVGMatrix;
17862 readonly type: number;
17863 setMatrix(matrix?: DOMMatrix2DInit): void;
17864 setRotate(angle: number, cx: number, cy: number): void;
17865 setScale(sx: number, sy: number): void;
17866 setSkewX(angle: number): void;
17867 setSkewY(angle: number): void;
17868 setTranslate(tx: number, ty: number): void;
17869 readonly SVG_TRANSFORM_UNKNOWN: 0;
17870 readonly SVG_TRANSFORM_MATRIX: 1;
17871 readonly SVG_TRANSFORM_TRANSLATE: 2;
17872 readonly SVG_TRANSFORM_SCALE: 3;
17873 readonly SVG_TRANSFORM_ROTATE: 4;
17874 readonly SVG_TRANSFORM_SKEWX: 5;
17875 readonly SVG_TRANSFORM_SKEWY: 6;
17878 declare var SVGTransform: {
17879 prototype: SVGTransform;
17880 new(): SVGTransform;
17881 readonly SVG_TRANSFORM_UNKNOWN: 0;
17882 readonly SVG_TRANSFORM_MATRIX: 1;
17883 readonly SVG_TRANSFORM_TRANSLATE: 2;
17884 readonly SVG_TRANSFORM_SCALE: 3;
17885 readonly SVG_TRANSFORM_ROTATE: 4;
17886 readonly SVG_TRANSFORM_SKEWX: 5;
17887 readonly SVG_TRANSFORM_SKEWY: 6;
17888 isInstance: IsInstance<SVGTransform>;
17891 interface SVGTransformList {
17892 readonly length: number;
17893 readonly numberOfItems: number;
17894 appendItem(newItem: SVGTransform): SVGTransform;
17896 consolidate(): SVGTransform | null;
17897 createSVGTransformFromMatrix(matrix?: DOMMatrix2DInit): SVGTransform;
17898 getItem(index: number): SVGTransform;
17899 initialize(newItem: SVGTransform): SVGTransform;
17900 insertItemBefore(newItem: SVGTransform, index: number): SVGTransform;
17901 removeItem(index: number): SVGTransform;
17902 replaceItem(newItem: SVGTransform, index: number): SVGTransform;
17903 [index: number]: SVGTransform;
17906 declare var SVGTransformList: {
17907 prototype: SVGTransformList;
17908 new(): SVGTransformList;
17909 isInstance: IsInstance<SVGTransformList>;
17912 interface SVGURIReference {
17913 readonly href: SVGAnimatedString;
17916 interface SVGUnitTypes {
17917 readonly SVG_UNIT_TYPE_UNKNOWN: 0;
17918 readonly SVG_UNIT_TYPE_USERSPACEONUSE: 1;
17919 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: 2;
17922 declare var SVGUnitTypes: {
17923 prototype: SVGUnitTypes;
17924 new(): SVGUnitTypes;
17925 readonly SVG_UNIT_TYPE_UNKNOWN: 0;
17926 readonly SVG_UNIT_TYPE_USERSPACEONUSE: 1;
17927 readonly SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: 2;
17928 isInstance: IsInstance<SVGUnitTypes>;
17931 interface SVGUseElement extends SVGGraphicsElement, SVGURIReference {
17932 readonly height: SVGAnimatedLength;
17933 readonly width: SVGAnimatedLength;
17934 readonly x: SVGAnimatedLength;
17935 readonly y: SVGAnimatedLength;
17936 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17937 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17938 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGUseElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17939 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17942 declare var SVGUseElement: {
17943 prototype: SVGUseElement;
17944 new(): SVGUseElement;
17945 isInstance: IsInstance<SVGUseElement>;
17948 interface SVGViewElement extends SVGElement, SVGFitToViewBox, SVGZoomAndPan {
17949 addEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
17950 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
17951 removeEventListener<K extends keyof SVGElementEventMap>(type: K, listener: (this: SVGViewElement, ev: SVGElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
17952 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
17955 declare var SVGViewElement: {
17956 prototype: SVGViewElement;
17957 new(): SVGViewElement;
17958 readonly SVG_ZOOMANDPAN_UNKNOWN: 0;
17959 readonly SVG_ZOOMANDPAN_DISABLE: 1;
17960 readonly SVG_ZOOMANDPAN_MAGNIFY: 2;
17961 isInstance: IsInstance<SVGViewElement>;
17964 interface SVGZoomAndPan {
17965 zoomAndPan: number;
17966 readonly SVG_ZOOMANDPAN_UNKNOWN: 0;
17967 readonly SVG_ZOOMANDPAN_DISABLE: 1;
17968 readonly SVG_ZOOMANDPAN_MAGNIFY: 2;
17971 /** Available only in secure contexts. */
17972 interface Sanitizer {
17973 sanitize(input: SanitizerInput): DocumentFragment;
17976 declare var Sanitizer: {
17977 prototype: Sanitizer;
17978 new(sanitizerConfig?: SanitizerConfig): Sanitizer;
17979 isInstance: IsInstance<Sanitizer>;
17982 interface Scheduler {
17983 postTask(callback: SchedulerPostTaskCallback, options?: SchedulerPostTaskOptions): Promise<any>;
17986 declare var Scheduler: {
17987 prototype: Scheduler;
17989 isInstance: IsInstance<Scheduler>;
17992 interface ScreenEventMap {
17994 "mozorientationchange": Event;
17997 interface Screen extends EventTarget {
17998 readonly availHeight: number;
17999 readonly availLeft: number;
18000 readonly availTop: number;
18001 readonly availWidth: number;
18002 readonly colorDepth: number;
18003 readonly colorGamut: ScreenColorGamut;
18004 readonly height: number;
18005 readonly left: number;
18006 readonly luminance: ScreenLuminance | null;
18007 readonly mozOrientation: string;
18008 onchange: ((this: Screen, ev: Event) => any) | null;
18009 onmozorientationchange: ((this: Screen, ev: Event) => any) | null;
18010 readonly orientation: ScreenOrientation;
18011 readonly pixelDepth: number;
18012 readonly top: number;
18013 readonly width: number;
18014 mozLockOrientation(orientation: string): boolean;
18015 mozLockOrientation(orientation: string[]): boolean;
18016 mozUnlockOrientation(): void;
18017 addEventListener<K extends keyof ScreenEventMap>(type: K, listener: (this: Screen, ev: ScreenEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18018 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18019 removeEventListener<K extends keyof ScreenEventMap>(type: K, listener: (this: Screen, ev: ScreenEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18020 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18023 declare var Screen: {
18026 isInstance: IsInstance<Screen>;
18029 interface ScreenLuminance {
18030 readonly max: number;
18031 readonly maxAverage: number;
18032 readonly min: number;
18035 declare var ScreenLuminance: {
18036 prototype: ScreenLuminance;
18037 new(): ScreenLuminance;
18038 isInstance: IsInstance<ScreenLuminance>;
18041 interface ScreenOrientationEventMap {
18045 interface ScreenOrientation extends EventTarget {
18046 readonly angle: number;
18047 onchange: ((this: ScreenOrientation, ev: Event) => any) | null;
18048 readonly type: OrientationType;
18049 lock(orientation: OrientationLockType): Promise<void>;
18051 addEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18052 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18053 removeEventListener<K extends keyof ScreenOrientationEventMap>(type: K, listener: (this: ScreenOrientation, ev: ScreenOrientationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18054 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18057 declare var ScreenOrientation: {
18058 prototype: ScreenOrientation;
18059 new(): ScreenOrientation;
18060 isInstance: IsInstance<ScreenOrientation>;
18063 interface ScriptProcessorNodeEventMap {
18064 "audioprocess": Event;
18067 interface ScriptProcessorNode extends AudioNode, AudioNodePassThrough {
18068 readonly bufferSize: number;
18069 onaudioprocess: ((this: ScriptProcessorNode, ev: Event) => any) | null;
18070 addEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18071 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18072 removeEventListener<K extends keyof ScriptProcessorNodeEventMap>(type: K, listener: (this: ScriptProcessorNode, ev: ScriptProcessorNodeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18073 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18076 declare var ScriptProcessorNode: {
18077 prototype: ScriptProcessorNode;
18078 new(): ScriptProcessorNode;
18079 isInstance: IsInstance<ScriptProcessorNode>;
18082 interface ScrollAreaEvent extends UIEvent {
18083 readonly height: number;
18084 readonly width: number;
18085 readonly x: number;
18086 readonly y: number;
18087 initScrollAreaEvent(type: string, canBubble?: boolean, cancelable?: boolean, view?: Window | null, detail?: number, x?: number, y?: number, width?: number, height?: number): void;
18090 declare var ScrollAreaEvent: {
18091 prototype: ScrollAreaEvent;
18092 new(): ScrollAreaEvent;
18093 isInstance: IsInstance<ScrollAreaEvent>;
18096 interface ScrollViewChangeEvent extends Event {
18097 readonly state: ScrollState;
18100 declare var ScrollViewChangeEvent: {
18101 prototype: ScrollViewChangeEvent;
18102 new(type: string, eventInit?: ScrollViewChangeEventInit): ScrollViewChangeEvent;
18103 isInstance: IsInstance<ScrollViewChangeEvent>;
18106 interface SecurityPolicyViolationEvent extends Event {
18107 readonly blockedURI: string;
18108 readonly columnNumber: number;
18109 readonly disposition: SecurityPolicyViolationEventDisposition;
18110 readonly documentURI: string;
18111 readonly effectiveDirective: string;
18112 readonly lineNumber: number;
18113 readonly originalPolicy: string;
18114 readonly referrer: string;
18115 readonly sample: string;
18116 readonly sourceFile: string;
18117 readonly statusCode: number;
18118 readonly violatedDirective: string;
18121 declare var SecurityPolicyViolationEvent: {
18122 prototype: SecurityPolicyViolationEvent;
18123 new(type: string, eventInitDict?: SecurityPolicyViolationEventInit): SecurityPolicyViolationEvent;
18124 isInstance: IsInstance<SecurityPolicyViolationEvent>;
18127 interface Selection {
18128 readonly anchorNode: Node | null;
18129 readonly anchorOffset: number;
18130 readonly areNormalAndCrossShadowBoundaryRangesCollapsed: boolean;
18131 caretBidiLevel: number | null;
18132 readonly direction: string;
18133 readonly focusNode: Node | null;
18134 readonly focusOffset: number;
18135 interlinePosition: boolean;
18136 readonly isCollapsed: boolean;
18137 readonly rangeCount: number;
18138 readonly selectionType: number;
18139 readonly type: string;
18140 GetRangesForInterval(beginNode: Node, beginOffset: number, endNode: Node, endOffset: number, allowAdjacent: boolean): Range[];
18141 addRange(range: Range): void;
18142 addSelectionListener(newListener: nsISelectionListener): void;
18143 collapse(node: Node | null, offset?: number): void;
18144 collapseToEnd(): void;
18145 collapseToStart(): void;
18146 containsNode(node: Node, allowPartialContainment?: boolean): boolean;
18147 deleteFromDocument(): void;
18149 extend(node: Node, offset?: number): void;
18150 getComposedRanges(...shadowRoots: ShadowRoot[]): StaticRange[];
18151 getRangeAt(index: number): Range;
18152 modify(alter: string, direction: string, granularity: string): void;
18153 removeAllRanges(): void;
18154 removeRange(range: Range): void;
18155 removeSelectionListener(listenerToRemove: nsISelectionListener): void;
18156 resetColors(): void;
18157 scrollIntoView(aRegion: number, aIsSynchronous: boolean, aVPercent: number, aHPercent: number): void;
18158 selectAllChildren(node: Node): void;
18159 setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
18160 setColors(aForegroundColor: string, aBackgroundColor: string, aAltForegroundColor: string, aAltBackgroundColor: string): void;
18161 setPosition(node: Node | null, offset?: number): void;
18162 toStringWithFormat(formatType: string, flags: number, wrapColumn: number): string;
18163 toString(): string;
18166 declare var Selection: {
18167 prototype: Selection;
18169 isInstance: IsInstance<Selection>;
18172 interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
18173 "statechange": Event;
18176 interface ServiceWorker extends EventTarget, AbstractWorker {
18177 onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
18178 readonly scriptURL: string;
18179 readonly state: ServiceWorkerState;
18180 postMessage(message: any, transferable: any[]): void;
18181 postMessage(message: any, options?: StructuredSerializeOptions): void;
18182 addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18183 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18184 removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18185 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18188 declare var ServiceWorker: {
18189 prototype: ServiceWorker;
18190 new(): ServiceWorker;
18191 isInstance: IsInstance<ServiceWorker>;
18194 interface ServiceWorkerContainerEventMap {
18195 "controllerchange": Event;
18197 "messageerror": Event;
18200 interface ServiceWorkerContainer extends EventTarget {
18201 readonly controller: ServiceWorker | null;
18202 oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
18203 onmessage: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
18204 onmessageerror: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
18205 readonly ready: Promise<ServiceWorkerRegistration>;
18206 getRegistration(documentURL?: string | URL): Promise<ServiceWorkerRegistration | undefined>;
18207 getRegistrations(): Promise<ServiceWorkerRegistration[]>;
18208 getScopeForUrl(url: string): string;
18209 register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
18210 startMessages(): void;
18211 addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18212 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18213 removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18214 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18217 declare var ServiceWorkerContainer: {
18218 prototype: ServiceWorkerContainer;
18219 new(): ServiceWorkerContainer;
18220 isInstance: IsInstance<ServiceWorkerContainer>;
18223 interface ServiceWorkerRegistrationEventMap {
18224 "updatefound": Event;
18227 interface ServiceWorkerRegistration extends EventTarget {
18228 readonly active: ServiceWorker | null;
18229 readonly installing: ServiceWorker | null;
18230 readonly navigationPreload: NavigationPreloadManager;
18231 onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
18232 readonly pushManager: PushManager;
18233 readonly scope: string;
18234 readonly updateViaCache: ServiceWorkerUpdateViaCache;
18235 readonly waiting: ServiceWorker | null;
18236 getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
18237 showNotification(title: string, options?: NotificationOptions): Promise<void>;
18238 unregister(): Promise<boolean>;
18239 update(): Promise<void>;
18240 addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18241 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18242 removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18243 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18246 declare var ServiceWorkerRegistration: {
18247 prototype: ServiceWorkerRegistration;
18248 new(): ServiceWorkerRegistration;
18249 isInstance: IsInstance<ServiceWorkerRegistration>;
18252 interface SessionStoreFormData {
18253 readonly children: (SessionStoreFormData | null)[] | null;
18254 readonly id: Record<string, FormDataValue> | null;
18255 readonly innerHTML: string | null;
18256 readonly url: string | null;
18257 readonly xpath: Record<string, FormDataValue> | null;
18261 declare var SessionStoreFormData: {
18262 prototype: SessionStoreFormData;
18263 new(): SessionStoreFormData;
18264 isInstance: IsInstance<SessionStoreFormData>;
18267 interface SessionStoreScrollData {
18268 readonly children: (SessionStoreScrollData | null)[] | null;
18269 readonly scroll: string | null;
18273 declare var SessionStoreScrollData: {
18274 prototype: SessionStoreScrollData;
18275 new(): SessionStoreScrollData;
18276 isInstance: IsInstance<SessionStoreScrollData>;
18279 interface ShadowRootEventMap {
18280 "slotchange": Event;
18283 interface ShadowRoot extends DocumentFragment, DocumentOrShadowRoot {
18284 readonly clonable: boolean;
18285 readonly delegatesFocus: boolean;
18286 readonly host: Element;
18288 readonly mode: ShadowRootMode;
18289 onslotchange: ((this: ShadowRoot, ev: Event) => any) | null;
18290 readonly serializable: boolean;
18291 readonly slotAssignment: SlotAssignmentMode;
18292 createElementAndAppendChildAt(parentNode: Node, localName: string): Node;
18293 getElementById(elementId: string): Element | null;
18294 getHTML(options?: GetHTMLOptions): string;
18295 importNodeAndAppendChildAt(parentNode: Node, node: Node, deep?: boolean): Node;
18296 isUAWidget(): boolean;
18297 setHTMLUnsafe(html: string): void;
18298 setIsUAWidget(): void;
18299 addEventListener<K extends keyof ShadowRootEventMap>(type: K, listener: (this: ShadowRoot, ev: ShadowRootEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18300 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18301 removeEventListener<K extends keyof ShadowRootEventMap>(type: K, listener: (this: ShadowRoot, ev: ShadowRootEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18302 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18305 declare var ShadowRoot: {
18306 prototype: ShadowRoot;
18308 isInstance: IsInstance<ShadowRoot>;
18311 interface SharedWorker extends EventTarget, AbstractWorker {
18312 readonly port: MessagePort;
18313 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18314 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18315 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18316 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18319 declare var SharedWorker: {
18320 prototype: SharedWorker;
18321 new(scriptURL: string | URL, options?: string | WorkerOptions): SharedWorker;
18322 isInstance: IsInstance<SharedWorker>;
18325 interface SimpleGestureEvent extends MouseEvent {
18326 allowedDirections: number;
18327 readonly clickCount: number;
18328 readonly delta: number;
18329 readonly direction: number;
18330 initSimpleGestureEvent(typeArg: string, canBubbleArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number, screenXArg?: number, screenYArg?: number, clientXArg?: number, clientYArg?: number, ctrlKeyArg?: boolean, altKeyArg?: boolean, shiftKeyArg?: boolean, metaKeyArg?: boolean, buttonArg?: number, relatedTargetArg?: EventTarget | null, allowedDirectionsArg?: number, directionArg?: number, deltaArg?: number, clickCount?: number): void;
18331 readonly DIRECTION_UP: 1;
18332 readonly DIRECTION_DOWN: 2;
18333 readonly DIRECTION_LEFT: 4;
18334 readonly DIRECTION_RIGHT: 8;
18335 readonly ROTATION_COUNTERCLOCKWISE: 1;
18336 readonly ROTATION_CLOCKWISE: 2;
18339 declare var SimpleGestureEvent: {
18340 prototype: SimpleGestureEvent;
18341 new(): SimpleGestureEvent;
18342 readonly DIRECTION_UP: 1;
18343 readonly DIRECTION_DOWN: 2;
18344 readonly DIRECTION_LEFT: 4;
18345 readonly DIRECTION_RIGHT: 8;
18346 readonly ROTATION_COUNTERCLOCKWISE: 1;
18347 readonly ROTATION_CLOCKWISE: 2;
18348 isInstance: IsInstance<SimpleGestureEvent>;
18351 interface SourceBufferEventMap {
18355 "updateend": Event;
18356 "updatestart": Event;
18359 interface SourceBuffer extends EventTarget {
18360 appendWindowEnd: number;
18361 appendWindowStart: number;
18362 readonly buffered: TimeRanges;
18363 mode: SourceBufferAppendMode;
18364 onabort: ((this: SourceBuffer, ev: Event) => any) | null;
18365 onerror: ((this: SourceBuffer, ev: Event) => any) | null;
18366 onupdate: ((this: SourceBuffer, ev: Event) => any) | null;
18367 onupdateend: ((this: SourceBuffer, ev: Event) => any) | null;
18368 onupdatestart: ((this: SourceBuffer, ev: Event) => any) | null;
18369 timestampOffset: number;
18370 readonly updating: boolean;
18372 appendBuffer(data: ArrayBuffer): void;
18373 appendBuffer(data: ArrayBufferView): void;
18374 appendBufferAsync(data: ArrayBuffer): Promise<void>;
18375 appendBufferAsync(data: ArrayBufferView): Promise<void>;
18376 changeType(type: string): void;
18377 remove(start: number, end: number): void;
18378 removeAsync(start: number, end: number): Promise<void>;
18379 addEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18380 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18381 removeEventListener<K extends keyof SourceBufferEventMap>(type: K, listener: (this: SourceBuffer, ev: SourceBufferEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18382 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18385 declare var SourceBuffer: {
18386 prototype: SourceBuffer;
18387 new(): SourceBuffer;
18388 isInstance: IsInstance<SourceBuffer>;
18391 interface SourceBufferListEventMap {
18392 "addsourcebuffer": Event;
18393 "removesourcebuffer": Event;
18396 interface SourceBufferList extends EventTarget {
18397 readonly length: number;
18398 onaddsourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
18399 onremovesourcebuffer: ((this: SourceBufferList, ev: Event) => any) | null;
18400 addEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18401 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18402 removeEventListener<K extends keyof SourceBufferListEventMap>(type: K, listener: (this: SourceBufferList, ev: SourceBufferListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18403 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18404 [index: number]: SourceBuffer;
18407 declare var SourceBufferList: {
18408 prototype: SourceBufferList;
18409 new(): SourceBufferList;
18410 isInstance: IsInstance<SourceBufferList>;
18413 interface SpeechGrammar {
18418 declare var SpeechGrammar: {
18419 prototype: SpeechGrammar;
18420 new(): SpeechGrammar;
18421 isInstance: IsInstance<SpeechGrammar>;
18424 interface SpeechGrammarList {
18425 readonly length: number;
18426 addFromString(string: string, weight?: number): void;
18427 addFromURI(src: string, weight?: number): void;
18428 item(index: number): SpeechGrammar;
18429 [index: number]: SpeechGrammar;
18432 declare var SpeechGrammarList: {
18433 prototype: SpeechGrammarList;
18434 new(): SpeechGrammarList;
18435 isInstance: IsInstance<SpeechGrammarList>;
18438 interface SpeechRecognitionEventMap {
18440 "audiostart": Event;
18446 "soundstart": Event;
18447 "speechend": Event;
18448 "speechstart": Event;
18452 interface SpeechRecognition extends EventTarget {
18453 continuous: boolean;
18454 grammars: SpeechGrammarList;
18455 interimResults: boolean;
18457 maxAlternatives: number;
18458 onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
18459 onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
18460 onend: ((this: SpeechRecognition, ev: Event) => any) | null;
18461 onerror: ((this: SpeechRecognition, ev: Event) => any) | null;
18462 onnomatch: ((this: SpeechRecognition, ev: Event) => any) | null;
18463 onresult: ((this: SpeechRecognition, ev: Event) => any) | null;
18464 onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
18465 onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
18466 onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
18467 onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
18468 onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
18469 serviceURI: string;
18471 start(stream?: MediaStream): void;
18473 addEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18474 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18475 removeEventListener<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18476 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18479 declare var SpeechRecognition: {
18480 prototype: SpeechRecognition;
18481 new(): SpeechRecognition;
18482 isInstance: IsInstance<SpeechRecognition>;
18485 interface SpeechRecognitionAlternative {
18486 readonly confidence: number;
18487 readonly transcript: string;
18490 declare var SpeechRecognitionAlternative: {
18491 prototype: SpeechRecognitionAlternative;
18492 new(): SpeechRecognitionAlternative;
18493 isInstance: IsInstance<SpeechRecognitionAlternative>;
18496 interface SpeechRecognitionError extends Event {
18497 readonly error: SpeechRecognitionErrorCode;
18498 readonly message: string | null;
18501 declare var SpeechRecognitionError: {
18502 prototype: SpeechRecognitionError;
18503 new(type: string, eventInitDict?: SpeechRecognitionErrorInit): SpeechRecognitionError;
18504 isInstance: IsInstance<SpeechRecognitionError>;
18507 interface SpeechRecognitionEvent extends Event {
18508 readonly emma: Document | null;
18509 readonly interpretation: any;
18510 readonly resultIndex: number;
18511 readonly results: SpeechRecognitionResultList | null;
18514 declare var SpeechRecognitionEvent: {
18515 prototype: SpeechRecognitionEvent;
18516 new(type: string, eventInitDict?: SpeechRecognitionEventInit): SpeechRecognitionEvent;
18517 isInstance: IsInstance<SpeechRecognitionEvent>;
18520 interface SpeechRecognitionResult {
18521 readonly isFinal: boolean;
18522 readonly length: number;
18523 item(index: number): SpeechRecognitionAlternative;
18524 [index: number]: SpeechRecognitionAlternative;
18527 declare var SpeechRecognitionResult: {
18528 prototype: SpeechRecognitionResult;
18529 new(): SpeechRecognitionResult;
18530 isInstance: IsInstance<SpeechRecognitionResult>;
18533 interface SpeechRecognitionResultList {
18534 readonly length: number;
18535 item(index: number): SpeechRecognitionResult;
18536 [index: number]: SpeechRecognitionResult;
18539 declare var SpeechRecognitionResultList: {
18540 prototype: SpeechRecognitionResultList;
18541 new(): SpeechRecognitionResultList;
18542 isInstance: IsInstance<SpeechRecognitionResultList>;
18545 interface SpeechSynthesisEventMap {
18546 "voiceschanged": Event;
18549 interface SpeechSynthesis extends EventTarget {
18550 onvoiceschanged: ((this: SpeechSynthesis, ev: Event) => any) | null;
18551 readonly paused: boolean;
18552 readonly pending: boolean;
18553 readonly speaking: boolean;
18556 getVoices(): SpeechSynthesisVoice[];
18559 speak(utterance: SpeechSynthesisUtterance): void;
18560 addEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18561 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18562 removeEventListener<K extends keyof SpeechSynthesisEventMap>(type: K, listener: (this: SpeechSynthesis, ev: SpeechSynthesisEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18563 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18566 declare var SpeechSynthesis: {
18567 prototype: SpeechSynthesis;
18568 new(): SpeechSynthesis;
18569 isInstance: IsInstance<SpeechSynthesis>;
18572 interface SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
18573 readonly error: SpeechSynthesisErrorCode;
18576 declare var SpeechSynthesisErrorEvent: {
18577 prototype: SpeechSynthesisErrorEvent;
18578 new(type: string, eventInitDict: SpeechSynthesisErrorEventInit): SpeechSynthesisErrorEvent;
18579 isInstance: IsInstance<SpeechSynthesisErrorEvent>;
18582 interface SpeechSynthesisEvent extends Event {
18583 readonly charIndex: number;
18584 readonly charLength: number | null;
18585 readonly elapsedTime: number;
18586 readonly name: string | null;
18587 readonly utterance: SpeechSynthesisUtterance;
18590 declare var SpeechSynthesisEvent: {
18591 prototype: SpeechSynthesisEvent;
18592 new(type: string, eventInitDict: SpeechSynthesisEventInit): SpeechSynthesisEvent;
18593 isInstance: IsInstance<SpeechSynthesisEvent>;
18596 interface SpeechSynthesisGetter {
18597 readonly speechSynthesis: SpeechSynthesis;
18600 interface SpeechSynthesisUtteranceEventMap {
18610 interface SpeechSynthesisUtterance extends EventTarget {
18611 readonly chosenVoiceURI: string;
18613 onboundary: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18614 onend: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18615 onerror: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18616 onmark: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18617 onpause: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18618 onresume: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18619 onstart: ((this: SpeechSynthesisUtterance, ev: Event) => any) | null;
18623 voice: SpeechSynthesisVoice | null;
18625 addEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18626 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18627 removeEventListener<K extends keyof SpeechSynthesisUtteranceEventMap>(type: K, listener: (this: SpeechSynthesisUtterance, ev: SpeechSynthesisUtteranceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18628 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18631 declare var SpeechSynthesisUtterance: {
18632 prototype: SpeechSynthesisUtterance;
18633 new(): SpeechSynthesisUtterance;
18634 new(text: string): SpeechSynthesisUtterance;
18635 isInstance: IsInstance<SpeechSynthesisUtterance>;
18638 interface SpeechSynthesisVoice {
18639 readonly default: boolean;
18640 readonly lang: string;
18641 readonly localService: boolean;
18642 readonly name: string;
18643 readonly voiceURI: string;
18646 declare var SpeechSynthesisVoice: {
18647 prototype: SpeechSynthesisVoice;
18648 new(): SpeechSynthesisVoice;
18649 isInstance: IsInstance<SpeechSynthesisVoice>;
18652 interface StackFrame {
18655 interface StaticRange extends AbstractRange {
18658 declare var StaticRange: {
18659 prototype: StaticRange;
18660 new(init: StaticRangeInit): StaticRange;
18661 isInstance: IsInstance<StaticRange>;
18664 interface StereoPannerNode extends AudioNode, AudioNodePassThrough {
18665 readonly pan: AudioParam;
18668 declare var StereoPannerNode: {
18669 prototype: StereoPannerNode;
18670 new(context: BaseAudioContext, options?: StereoPannerOptions): StereoPannerNode;
18671 isInstance: IsInstance<StereoPannerNode>;
18674 interface Storage {
18675 readonly hasSnapshot: boolean;
18676 readonly length: number;
18677 readonly snapshotUsage: number;
18678 beginExplicitSnapshot(): void;
18679 checkpointExplicitSnapshot(): void;
18682 endExplicitSnapshot(): void;
18683 getItem(key: string): string | null;
18684 key(index: number): string | null;
18686 removeItem(key: string): void;
18687 setItem(key: string, value: string): void;
18690 declare var Storage: {
18691 prototype: Storage;
18693 isInstance: IsInstance<Storage>;
18696 interface StorageEvent extends Event {
18697 readonly key: string | null;
18698 readonly newValue: string | null;
18699 readonly oldValue: string | null;
18700 readonly storageArea: Storage | null;
18701 readonly url: string;
18702 initStorageEvent(type: string, canBubble?: boolean, cancelable?: boolean, key?: string | null, oldValue?: string | null, newValue?: string | null, url?: string | URL, storageArea?: Storage | null): void;
18705 declare var StorageEvent: {
18706 prototype: StorageEvent;
18707 new(type: string, eventInitDict?: StorageEventInit): StorageEvent;
18708 isInstance: IsInstance<StorageEvent>;
18711 /** Available only in secure contexts. */
18712 interface StorageManager {
18713 estimate(): Promise<StorageEstimate>;
18714 getDirectory(): Promise<FileSystemDirectoryHandle>;
18715 persist(): Promise<boolean>;
18716 persisted(): Promise<boolean>;
18720 declare var StorageManager: {
18721 prototype: StorageManager;
18722 new(): StorageManager;
18723 isInstance: IsInstance<StorageManager>;
18726 interface StreamFilterEventMap {
18733 interface StreamFilter extends EventTarget {
18734 readonly error: string;
18735 ondata: ((this: StreamFilter, ev: Event) => any) | null;
18736 onerror: ((this: StreamFilter, ev: Event) => any) | null;
18737 onstart: ((this: StreamFilter, ev: Event) => any) | null;
18738 onstop: ((this: StreamFilter, ev: Event) => any) | null;
18739 readonly status: StreamFilterStatus;
18741 disconnect(): void;
18744 write(data: ArrayBuffer | Uint8Array): void;
18745 addEventListener<K extends keyof StreamFilterEventMap>(type: K, listener: (this: StreamFilter, ev: StreamFilterEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18746 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18747 removeEventListener<K extends keyof StreamFilterEventMap>(type: K, listener: (this: StreamFilter, ev: StreamFilterEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18748 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18751 declare var StreamFilter: {
18752 prototype: StreamFilter;
18753 new(): StreamFilter;
18754 isInstance: IsInstance<StreamFilter>;
18755 create(requestId: number, addonId: string): StreamFilter;
18758 interface StreamFilterDataEvent extends Event {
18759 readonly data: ArrayBuffer;
18762 declare var StreamFilterDataEvent: {
18763 prototype: StreamFilterDataEvent;
18764 new(type: string, eventInitDict?: StreamFilterDataEventInit): StreamFilterDataEvent;
18765 isInstance: IsInstance<StreamFilterDataEvent>;
18768 interface StructuredCloneHolder {
18769 deserialize(global: any, keepData?: boolean): any;
18772 declare var StructuredCloneHolder: {
18773 prototype: StructuredCloneHolder;
18774 new(name: string, anonymizedName: string | null, data: any, global?: any): StructuredCloneHolder;
18775 isInstance: IsInstance<StructuredCloneHolder>;
18778 interface StructuredCloneTester {
18779 readonly deserializable: boolean;
18780 readonly serializable: boolean;
18783 declare var StructuredCloneTester: {
18784 prototype: StructuredCloneTester;
18785 new(serializable: boolean, deserializable: boolean): StructuredCloneTester;
18786 isInstance: IsInstance<StructuredCloneTester>;
18789 interface StyleSheet {
18790 readonly associatedDocument: Document | null;
18791 readonly constructed: boolean;
18793 readonly href: string | null;
18794 readonly media: MediaList;
18795 readonly ownerNode: Node | null;
18796 readonly parentStyleSheet: StyleSheet | null;
18797 readonly sourceMapURL: string;
18798 readonly sourceURL: string;
18799 readonly title: string | null;
18800 readonly type: string;
18803 declare var StyleSheet: {
18804 prototype: StyleSheet;
18806 isInstance: IsInstance<StyleSheet>;
18809 interface StyleSheetApplicableStateChangeEvent extends Event {
18810 readonly applicable: boolean;
18811 readonly stylesheet: CSSStyleSheet | null;
18814 declare var StyleSheetApplicableStateChangeEvent: {
18815 prototype: StyleSheetApplicableStateChangeEvent;
18816 new(type: string, eventInitDict?: StyleSheetApplicableStateChangeEventInit): StyleSheetApplicableStateChangeEvent;
18817 isInstance: IsInstance<StyleSheetApplicableStateChangeEvent>;
18820 interface StyleSheetList {
18821 readonly length: number;
18822 item(index: number): CSSStyleSheet | null;
18823 [index: number]: CSSStyleSheet;
18826 declare var StyleSheetList: {
18827 prototype: StyleSheetList;
18828 new(): StyleSheetList;
18829 isInstance: IsInstance<StyleSheetList>;
18832 interface StyleSheetRemovedEvent extends Event {
18833 readonly stylesheet: CSSStyleSheet | null;
18836 declare var StyleSheetRemovedEvent: {
18837 prototype: StyleSheetRemovedEvent;
18838 new(type: string, eventInitDict?: StyleSheetRemovedEventInit): StyleSheetRemovedEvent;
18839 isInstance: IsInstance<StyleSheetRemovedEvent>;
18842 interface SubmitEvent extends Event {
18843 readonly submitter: HTMLElement | null;
18846 declare var SubmitEvent: {
18847 prototype: SubmitEvent;
18848 new(type: string, eventInitDict?: SubmitEventInit): SubmitEvent;
18849 isInstance: IsInstance<SubmitEvent>;
18852 /** Available only in secure contexts. */
18853 interface SubtleCrypto {
18854 decrypt(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<any>;
18855 deriveBits(algorithm: AlgorithmIdentifier, baseKey: CryptoKey, length: number): Promise<any>;
18856 deriveKey(algorithm: AlgorithmIdentifier, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<any>;
18857 digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<any>;
18858 encrypt(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<any>;
18859 exportKey(format: KeyFormat, key: CryptoKey): Promise<any>;
18860 generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<any>;
18861 importKey(format: KeyFormat, keyData: any, algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<any>;
18862 sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<any>;
18863 unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier, unwrappedKeyAlgorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<any>;
18864 verify(algorithm: AlgorithmIdentifier, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<any>;
18865 wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier): Promise<any>;
18868 declare var SubtleCrypto: {
18869 prototype: SubtleCrypto;
18870 new(): SubtleCrypto;
18871 isInstance: IsInstance<SubtleCrypto>;
18874 interface SyncMessageSender extends MessageSender, SyncMessageSenderMixin {
18877 declare var SyncMessageSender: {
18878 prototype: SyncMessageSender;
18879 new(): SyncMessageSender;
18880 isInstance: IsInstance<SyncMessageSender>;
18883 interface SyncMessageSenderMixin {
18884 sendSyncMessage(messageName?: string | null, obj?: any): any[];
18887 interface TCPServerSocketEventMap {
18892 interface TCPServerSocket extends EventTarget {
18893 readonly localPort: number;
18894 onconnect: ((this: TCPServerSocket, ev: Event) => any) | null;
18895 onerror: ((this: TCPServerSocket, ev: Event) => any) | null;
18897 addEventListener<K extends keyof TCPServerSocketEventMap>(type: K, listener: (this: TCPServerSocket, ev: TCPServerSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18898 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18899 removeEventListener<K extends keyof TCPServerSocketEventMap>(type: K, listener: (this: TCPServerSocket, ev: TCPServerSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18900 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18903 declare var TCPServerSocket: {
18904 prototype: TCPServerSocket;
18905 new(port: number, options?: ServerSocketOptions, backlog?: number): TCPServerSocket;
18906 isInstance: IsInstance<TCPServerSocket>;
18909 interface TCPServerSocketEvent extends Event {
18910 readonly socket: TCPSocket;
18913 declare var TCPServerSocketEvent: {
18914 prototype: TCPServerSocketEvent;
18915 new(type: string, eventInitDict?: TCPServerSocketEventInit): TCPServerSocketEvent;
18916 isInstance: IsInstance<TCPServerSocketEvent>;
18919 interface TCPSocketEventMap {
18927 interface TCPSocket extends EventTarget {
18928 readonly binaryType: TCPSocketBinaryType;
18929 readonly bufferedAmount: number;
18930 readonly host: string;
18931 onclose: ((this: TCPSocket, ev: Event) => any) | null;
18932 ondata: ((this: TCPSocket, ev: Event) => any) | null;
18933 ondrain: ((this: TCPSocket, ev: Event) => any) | null;
18934 onerror: ((this: TCPSocket, ev: Event) => any) | null;
18935 onopen: ((this: TCPSocket, ev: Event) => any) | null;
18936 readonly port: number;
18937 readonly readyState: TCPReadyState;
18938 readonly ssl: boolean;
18939 readonly transport: nsISocketTransport | null;
18941 closeImmediately(): void;
18943 send(data: string): boolean;
18944 send(data: ArrayBuffer, byteOffset?: number, byteLength?: number): boolean;
18946 upgradeToSecure(): void;
18947 addEventListener<K extends keyof TCPSocketEventMap>(type: K, listener: (this: TCPSocket, ev: TCPSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
18948 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
18949 removeEventListener<K extends keyof TCPSocketEventMap>(type: K, listener: (this: TCPSocket, ev: TCPSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
18950 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
18953 declare var TCPSocket: {
18954 prototype: TCPSocket;
18955 new(host: string, port: number, options?: SocketOptions): TCPSocket;
18956 isInstance: IsInstance<TCPSocket>;
18959 interface TCPSocketErrorEvent extends Event {
18960 readonly errorCode: number;
18961 readonly message: string;
18962 readonly name: string;
18965 declare var TCPSocketErrorEvent: {
18966 prototype: TCPSocketErrorEvent;
18967 new(type: string, eventInitDict?: TCPSocketErrorEventInit): TCPSocketErrorEvent;
18968 isInstance: IsInstance<TCPSocketErrorEvent>;
18971 interface TCPSocketEvent extends Event {
18972 readonly data: any;
18975 declare var TCPSocketEvent: {
18976 prototype: TCPSocketEvent;
18977 new(type: string, eventInitDict?: TCPSocketEventInit): TCPSocketEvent;
18978 isInstance: IsInstance<TCPSocketEvent>;
18981 interface TaskController extends AbortController {
18982 setPriority(priority: TaskPriority): void;
18985 declare var TaskController: {
18986 prototype: TaskController;
18987 new(init?: TaskControllerInit): TaskController;
18988 isInstance: IsInstance<TaskController>;
18991 interface TaskPriorityChangeEvent extends Event {
18992 readonly previousPriority: TaskPriority;
18995 declare var TaskPriorityChangeEvent: {
18996 prototype: TaskPriorityChangeEvent;
18997 new(type: string, priorityChangeEventInitDict: TaskPriorityChangeEventInit): TaskPriorityChangeEvent;
18998 isInstance: IsInstance<TaskPriorityChangeEvent>;
19001 interface TaskSignalEventMap extends AbortSignalEventMap {
19002 "prioritychange": Event;
19005 interface TaskSignal extends AbortSignal {
19006 onprioritychange: ((this: TaskSignal, ev: Event) => any) | null;
19007 readonly priority: TaskPriority;
19008 addEventListener<K extends keyof TaskSignalEventMap>(type: K, listener: (this: TaskSignal, ev: TaskSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19009 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19010 removeEventListener<K extends keyof TaskSignalEventMap>(type: K, listener: (this: TaskSignal, ev: TaskSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19011 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19014 declare var TaskSignal: {
19015 prototype: TaskSignal;
19017 isInstance: IsInstance<TaskSignal>;
19020 interface TestFunctions {
19021 allowSharedArrayBuffer: ArrayBuffer;
19022 allowSharedArrayBufferView: ArrayBufferView;
19023 arrayBuffer: ArrayBuffer;
19024 arrayBufferView: ArrayBufferView;
19025 clampedNullableOctet: number | null;
19026 enforcedNullableOctet: number | null;
19027 readonly one: number;
19028 sequenceOfAllowSharedArrayBuffer: ArrayBuffer[];
19029 sequenceOfAllowSharedArrayBufferView: ArrayBufferView[];
19030 sequenceOfArrayBuffer: ArrayBuffer[];
19031 sequenceOfArrayBufferView: ArrayBufferView[];
19032 readonly two: number;
19033 readonly wrapperCachedNonISupportsObject: WrapperCachedNonISupportsTestInterface;
19034 getLongLiteralString(): string;
19035 getMediumLiteralString(): string;
19036 getShortLiteralString(): string;
19037 getStringDataAsAString(): string;
19038 getStringDataAsAString(length: number): string;
19039 getStringDataAsDOMString(length?: number): string;
19040 getStringType(str: string): StringType;
19041 getStringbufferString(input: string): string;
19042 setStringData(arg: string): void;
19043 staticAndNonStaticOverload(): boolean;
19044 staticAndNonStaticOverload(foo?: number): boolean;
19045 stringbufferMatchesStored(str: string): boolean;
19046 testAllowShared(buffer: ArrayBufferView): void;
19047 testAllowShared(buffer: ArrayBuffer): void;
19048 testDictWithAllowShared(buffer?: DictWithAllowSharedBufferSource): void;
19049 testNotAllowShared(buffer: ArrayBufferView): void;
19050 testNotAllowShared(buffer: ArrayBuffer): void;
19051 testNotAllowShared(buffer: string): void;
19052 testThrowNsresult(): void;
19053 testThrowNsresultFromNative(): void;
19054 testUnionOfAllowSharedBuffferSource(foo: ArrayBuffer | ArrayBufferView): void;
19055 testUnionOfBuffferSource(foo: ArrayBuffer | ArrayBufferView | string): void;
19059 declare var TestFunctions: {
19060 prototype: TestFunctions;
19061 new(): TestFunctions;
19062 isInstance: IsInstance<TestFunctions>;
19063 passThroughCallbackPromise(callback: PromiseReturner): Promise<any>;
19064 passThroughPromise(arg: any): Promise<any>;
19065 throwToRejectPromise(): Promise<any>;
19066 throwUncatchableException(): void;
19069 interface TestInterfaceAsyncIterableDouble {
19072 declare var TestInterfaceAsyncIterableDouble: {
19073 prototype: TestInterfaceAsyncIterableDouble;
19074 new(): TestInterfaceAsyncIterableDouble;
19075 isInstance: IsInstance<TestInterfaceAsyncIterableDouble>;
19078 interface TestInterfaceAsyncIterableDoubleUnion {
19081 declare var TestInterfaceAsyncIterableDoubleUnion: {
19082 prototype: TestInterfaceAsyncIterableDoubleUnion;
19083 new(): TestInterfaceAsyncIterableDoubleUnion;
19084 isInstance: IsInstance<TestInterfaceAsyncIterableDoubleUnion>;
19087 interface TestInterfaceAsyncIterableSingle {
19090 declare var TestInterfaceAsyncIterableSingle: {
19091 prototype: TestInterfaceAsyncIterableSingle;
19092 new(options?: TestInterfaceAsyncIterableSingleOptions): TestInterfaceAsyncIterableSingle;
19093 isInstance: IsInstance<TestInterfaceAsyncIterableSingle>;
19096 interface TestInterfaceAsyncIterableSingleWithArgs {
19097 readonly returnCallCount: number;
19098 readonly returnLastCalledWith: any;
19101 declare var TestInterfaceAsyncIterableSingleWithArgs: {
19102 prototype: TestInterfaceAsyncIterableSingleWithArgs;
19103 new(): TestInterfaceAsyncIterableSingleWithArgs;
19104 isInstance: IsInstance<TestInterfaceAsyncIterableSingleWithArgs>;
19107 interface TestInterfaceIterableDouble {
19108 forEach(callbackfn: (value: string, key: string, parent: TestInterfaceIterableDouble) => void, thisArg?: any): void;
19111 declare var TestInterfaceIterableDouble: {
19112 prototype: TestInterfaceIterableDouble;
19113 new(): TestInterfaceIterableDouble;
19114 isInstance: IsInstance<TestInterfaceIterableDouble>;
19117 interface TestInterfaceIterableDoubleUnion {
19118 forEach(callbackfn: (value: string | number, key: string, parent: TestInterfaceIterableDoubleUnion) => void, thisArg?: any): void;
19121 declare var TestInterfaceIterableDoubleUnion: {
19122 prototype: TestInterfaceIterableDoubleUnion;
19123 new(): TestInterfaceIterableDoubleUnion;
19124 isInstance: IsInstance<TestInterfaceIterableDoubleUnion>;
19127 interface TestInterfaceIterableSingle {
19128 readonly length: number;
19129 forEach(callbackfn: (value: number, key: number, parent: TestInterfaceIterableSingle) => void, thisArg?: any): void;
19130 [index: number]: number;
19133 declare var TestInterfaceIterableSingle: {
19134 prototype: TestInterfaceIterableSingle;
19135 new(): TestInterfaceIterableSingle;
19136 isInstance: IsInstance<TestInterfaceIterableSingle>;
19139 interface TestInterfaceJSEventMap {
19140 "something": Event;
19143 interface TestInterfaceJS extends EventTarget {
19144 readonly anyArg: any;
19146 readonly objectArg: any;
19148 onsomething: ((this: TestInterfaceJS, ev: Event) => any) | null;
19149 anySequenceLength(seq: any[]): number;
19150 convertSVS(svs: string): string;
19151 getCallerPrincipal(): string;
19152 getDictionaryArg(): TestInterfaceJSDictionary;
19153 getDictionaryAttr(): TestInterfaceJSDictionary;
19154 objectSequenceLength(seq: any[]): number;
19155 pingPongAny(arg: any): any;
19156 pingPongDictionary(dict?: TestInterfaceJSDictionary): TestInterfaceJSDictionary;
19157 pingPongDictionaryOrLong(dictOrLong?: TestInterfaceJSUnionableDictionary | number): number;
19158 pingPongNullableUnion(something: TestInterfaceJS | number | null): TestInterfaceJS | number | null;
19159 pingPongObject(obj: any): any;
19160 pingPongObjectOrString(objOrString: any): any;
19161 pingPongRecord(rec: Record<string, any>): string;
19162 pingPongUnion(something: TestInterfaceJS | number): TestInterfaceJS | number;
19163 pingPongUnionContainingNull(something: TestInterfaceJS | string): string | TestInterfaceJS;
19164 returnBadUnion(): Location | TestInterfaceJS;
19165 setDictionaryAttr(dict?: TestInterfaceJSDictionary): void;
19166 testPromiseWithDOMExceptionThrowingPromiseInit(): Promise<void>;
19167 testPromiseWithDOMExceptionThrowingThenFunction(): Promise<void>;
19168 testPromiseWithDOMExceptionThrowingThenable(): Promise<void>;
19169 testPromiseWithThrowingChromePromiseInit(): Promise<void>;
19170 testPromiseWithThrowingChromeThenFunction(): Promise<void>;
19171 testPromiseWithThrowingChromeThenable(): Promise<void>;
19172 testPromiseWithThrowingContentPromiseInit(func: Function): Promise<void>;
19173 testPromiseWithThrowingContentThenFunction(func: AnyCallback): Promise<void>;
19174 testPromiseWithThrowingContentThenable(thenable: any): Promise<void>;
19175 testSequenceOverload(arg: string[]): void;
19176 testSequenceOverload(arg: string): void;
19177 testSequenceUnion(arg: string[] | string): void;
19178 testThrowCallbackError(callback: Function): void;
19179 testThrowDOMException(): void;
19180 testThrowError(): void;
19181 testThrowSelfHosted(): void;
19182 testThrowTypeError(): void;
19183 testThrowXraySelfHosted(): void;
19184 addEventListener<K extends keyof TestInterfaceJSEventMap>(type: K, listener: (this: TestInterfaceJS, ev: TestInterfaceJSEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19185 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19186 removeEventListener<K extends keyof TestInterfaceJSEventMap>(type: K, listener: (this: TestInterfaceJS, ev: TestInterfaceJSEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19187 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19190 declare var TestInterfaceJS: {
19191 prototype: TestInterfaceJS;
19192 new(anyArg?: any, objectArg?: any, dictionaryArg?: TestInterfaceJSDictionary): TestInterfaceJS;
19193 isInstance: IsInstance<TestInterfaceJS>;
19196 interface TestInterfaceLength {
19199 declare var TestInterfaceLength: {
19200 prototype: TestInterfaceLength;
19201 new(arg: boolean): TestInterfaceLength;
19202 isInstance: IsInstance<TestInterfaceLength>;
19205 interface TestInterfaceMaplike {
19206 clearInternal(): void;
19207 deleteInternal(aKey: string): boolean;
19208 getInternal(aKey: string): number;
19209 hasInternal(aKey: string): boolean;
19210 setInternal(aKey: string, aValue: number): void;
19211 forEach(callbackfn: (value: number, key: string, parent: TestInterfaceMaplike) => void, thisArg?: any): void;
19214 declare var TestInterfaceMaplike: {
19215 prototype: TestInterfaceMaplike;
19216 new(): TestInterfaceMaplike;
19217 isInstance: IsInstance<TestInterfaceMaplike>;
19220 interface TestInterfaceMaplikeJSObject {
19221 clearInternal(): void;
19222 deleteInternal(aKey: string): boolean;
19223 getInternal(aKey: string): any;
19224 hasInternal(aKey: string): boolean;
19225 setInternal(aKey: string, aObject: any): void;
19226 forEach(callbackfn: (value: any, key: string, parent: TestInterfaceMaplikeJSObject) => void, thisArg?: any): void;
19229 declare var TestInterfaceMaplikeJSObject: {
19230 prototype: TestInterfaceMaplikeJSObject;
19231 new(): TestInterfaceMaplikeJSObject;
19232 isInstance: IsInstance<TestInterfaceMaplikeJSObject>;
19235 interface TestInterfaceMaplikeObject {
19236 clearInternal(): void;
19237 deleteInternal(aKey: string): boolean;
19238 getInternal(aKey: string): TestInterfaceMaplike | null;
19239 hasInternal(aKey: string): boolean;
19240 setInternal(aKey: string): void;
19241 forEach(callbackfn: (value: TestInterfaceMaplike, key: string, parent: TestInterfaceMaplikeObject) => void, thisArg?: any): void;
19244 declare var TestInterfaceMaplikeObject: {
19245 prototype: TestInterfaceMaplikeObject;
19246 new(): TestInterfaceMaplikeObject;
19247 isInstance: IsInstance<TestInterfaceMaplikeObject>;
19250 interface TestInterfaceObservableArray {
19251 observableArrayBoolean: boolean[];
19252 observableArrayInterface: TestInterfaceObservableArray[];
19253 observableArrayObject: any[];
19254 booleanAppendElementInternal(value: boolean): void;
19255 booleanElementAtInternal(index: number): boolean;
19256 booleanLengthInternal(): number;
19257 booleanRemoveLastElementInternal(): void;
19258 booleanReplaceElementAtInternal(index: number, value: boolean): void;
19259 interfaceAppendElementInternal(value: TestInterfaceObservableArray): void;
19260 interfaceElementAtInternal(index: number): TestInterfaceObservableArray;
19261 interfaceLengthInternal(): number;
19262 interfaceRemoveLastElementInternal(): void;
19263 interfaceReplaceElementAtInternal(index: number, value: TestInterfaceObservableArray): void;
19264 objectAppendElementInternal(value: any): void;
19265 objectElementAtInternal(index: number): any;
19266 objectLengthInternal(): number;
19267 objectRemoveLastElementInternal(): void;
19268 objectReplaceElementAtInternal(index: number, value: any): void;
19271 declare var TestInterfaceObservableArray: {
19272 prototype: TestInterfaceObservableArray;
19273 new(callbacks?: ObservableArrayCallbacks): TestInterfaceObservableArray;
19274 isInstance: IsInstance<TestInterfaceObservableArray>;
19277 interface TestInterfaceSetlike {
19278 forEach(callbackfn: (value: string, key: string, parent: TestInterfaceSetlike) => void, thisArg?: any): void;
19281 declare var TestInterfaceSetlike: {
19282 prototype: TestInterfaceSetlike;
19283 new(): TestInterfaceSetlike;
19284 isInstance: IsInstance<TestInterfaceSetlike>;
19287 interface TestInterfaceSetlikeNode {
19288 forEach(callbackfn: (value: Node, key: Node, parent: TestInterfaceSetlikeNode) => void, thisArg?: any): void;
19291 declare var TestInterfaceSetlikeNode: {
19292 prototype: TestInterfaceSetlikeNode;
19293 new(): TestInterfaceSetlikeNode;
19294 isInstance: IsInstance<TestInterfaceSetlikeNode>;
19297 interface TestTrialInterface {
19300 declare var TestTrialInterface: {
19301 prototype: TestTrialInterface;
19302 new(): TestTrialInterface;
19303 isInstance: IsInstance<TestTrialInterface>;
19306 interface TestingDeprecatedInterface {
19307 readonly deprecatedAttribute: boolean;
19308 deprecatedMethod(): void;
19311 declare var TestingDeprecatedInterface: {
19312 prototype: TestingDeprecatedInterface;
19313 new(): TestingDeprecatedInterface;
19314 isInstance: IsInstance<TestingDeprecatedInterface>;
19317 interface Text extends CharacterData, GeometryUtils {
19318 readonly assignedSlot: HTMLSlotElement | null;
19319 readonly openOrClosedAssignedSlot: HTMLSlotElement | null;
19320 readonly wholeText: string;
19321 splitText(offset: number): Text;
19324 declare var Text: {
19326 new(data?: string): Text;
19327 isInstance: IsInstance<Text>;
19330 interface TextClause {
19331 readonly endOffset: number;
19332 readonly isCaret: boolean;
19333 readonly isTargetClause: boolean;
19334 readonly startOffset: number;
19337 declare var TextClause: {
19338 prototype: TextClause;
19340 isInstance: IsInstance<TextClause>;
19343 interface TextDecoder extends TextDecoderCommon {
19344 decode(input?: BufferSource, options?: TextDecodeOptions): string;
19347 declare var TextDecoder: {
19348 prototype: TextDecoder;
19349 new(label?: string, options?: TextDecoderOptions): TextDecoder;
19350 isInstance: IsInstance<TextDecoder>;
19353 interface TextDecoderCommon {
19354 readonly encoding: string;
19355 readonly fatal: boolean;
19356 readonly ignoreBOM: boolean;
19359 interface TextDecoderStream extends GenericTransformStream, TextDecoderCommon {
19362 declare var TextDecoderStream: {
19363 prototype: TextDecoderStream;
19364 new(label?: string, options?: TextDecoderOptions): TextDecoderStream;
19365 isInstance: IsInstance<TextDecoderStream>;
19368 interface TextEncoder extends TextEncoderCommon {
19369 encode(input?: string): Uint8Array;
19370 encodeInto(source: JSString, destination: Uint8Array): TextEncoderEncodeIntoResult;
19373 declare var TextEncoder: {
19374 prototype: TextEncoder;
19375 new(): TextEncoder;
19376 isInstance: IsInstance<TextEncoder>;
19379 interface TextEncoderCommon {
19380 readonly encoding: string;
19383 interface TextEncoderStream extends GenericTransformStream, TextEncoderCommon {
19386 declare var TextEncoderStream: {
19387 prototype: TextEncoderStream;
19388 new(): TextEncoderStream;
19389 isInstance: IsInstance<TextEncoderStream>;
19392 interface TextEvent extends UIEvent {
19393 readonly data: string;
19394 initTextEvent(type: string, bubbles?: boolean, cancelable?: boolean, view?: Window | null, data?: string): void;
19397 declare var TextEvent: {
19398 prototype: TextEvent;
19400 isInstance: IsInstance<TextEvent>;
19403 interface TextMetrics {
19404 readonly actualBoundingBoxAscent: number;
19405 readonly actualBoundingBoxDescent: number;
19406 readonly actualBoundingBoxLeft: number;
19407 readonly actualBoundingBoxRight: number;
19408 readonly alphabeticBaseline: number;
19409 readonly emHeightAscent: number;
19410 readonly emHeightDescent: number;
19411 readonly fontBoundingBoxAscent: number;
19412 readonly fontBoundingBoxDescent: number;
19413 readonly hangingBaseline: number;
19414 readonly ideographicBaseline: number;
19415 readonly width: number;
19418 declare var TextMetrics: {
19419 prototype: TextMetrics;
19420 new(): TextMetrics;
19421 isInstance: IsInstance<TextMetrics>;
19424 interface TextTrackEventMap {
19425 "cuechange": Event;
19428 interface TextTrack extends EventTarget {
19429 readonly activeCues: TextTrackCueList | null;
19430 readonly cues: TextTrackCueList | null;
19431 readonly id: string;
19432 readonly inBandMetadataTrackDispatchType: string;
19433 readonly kind: TextTrackKind;
19434 readonly label: string;
19435 readonly language: string;
19436 mode: TextTrackMode;
19437 oncuechange: ((this: TextTrack, ev: Event) => any) | null;
19438 readonly textTrackList: TextTrackList | null;
19439 addCue(cue: VTTCue): void;
19440 removeCue(cue: VTTCue): void;
19441 addEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19442 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19443 removeEventListener<K extends keyof TextTrackEventMap>(type: K, listener: (this: TextTrack, ev: TextTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19444 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19447 declare var TextTrack: {
19448 prototype: TextTrack;
19450 isInstance: IsInstance<TextTrack>;
19453 interface TextTrackCueEventMap {
19458 interface TextTrackCue extends EventTarget {
19461 onenter: ((this: TextTrackCue, ev: Event) => any) | null;
19462 onexit: ((this: TextTrackCue, ev: Event) => any) | null;
19463 pauseOnExit: boolean;
19465 readonly track: TextTrack | null;
19466 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19467 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19468 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: TextTrackCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19469 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19472 declare var TextTrackCue: {
19473 prototype: TextTrackCue;
19474 new(): TextTrackCue;
19475 isInstance: IsInstance<TextTrackCue>;
19478 interface TextTrackCueList {
19479 readonly length: number;
19480 getCueById(id: string): VTTCue | null;
19481 [index: number]: VTTCue;
19484 declare var TextTrackCueList: {
19485 prototype: TextTrackCueList;
19486 new(): TextTrackCueList;
19487 isInstance: IsInstance<TextTrackCueList>;
19490 interface TextTrackListEventMap {
19493 "removetrack": Event;
19496 interface TextTrackList extends EventTarget {
19497 readonly length: number;
19498 readonly mediaElement: HTMLMediaElement | null;
19499 onaddtrack: ((this: TextTrackList, ev: Event) => any) | null;
19500 onchange: ((this: TextTrackList, ev: Event) => any) | null;
19501 onremovetrack: ((this: TextTrackList, ev: Event) => any) | null;
19502 getTrackById(id: string): TextTrack | null;
19503 addEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19504 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19505 removeEventListener<K extends keyof TextTrackListEventMap>(type: K, listener: (this: TextTrackList, ev: TextTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19506 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19507 [index: number]: TextTrack;
19510 declare var TextTrackList: {
19511 prototype: TextTrackList;
19512 new(): TextTrackList;
19513 isInstance: IsInstance<TextTrackList>;
19516 interface TimeEvent extends Event {
19517 readonly detail: number;
19518 readonly view: WindowProxy | null;
19519 initTimeEvent(aType: string, aView?: Window | null, aDetail?: number): void;
19522 declare var TimeEvent: {
19523 prototype: TimeEvent;
19525 isInstance: IsInstance<TimeEvent>;
19528 interface TimeRanges {
19529 readonly length: number;
19530 end(index: number): number;
19531 start(index: number): number;
19534 declare var TimeRanges: {
19535 prototype: TimeRanges;
19537 isInstance: IsInstance<TimeRanges>;
19540 interface ToggleEvent extends Event {
19541 readonly newState: string;
19542 readonly oldState: string;
19545 declare var ToggleEvent: {
19546 prototype: ToggleEvent;
19547 new(type: string, eventInitDict?: ToggleEventInit): ToggleEvent;
19548 isInstance: IsInstance<ToggleEvent>;
19552 readonly clientX: number;
19553 readonly clientY: number;
19554 readonly force: number;
19555 readonly identifier: number;
19556 readonly pageX: number;
19557 readonly pageY: number;
19558 readonly radiusX: number;
19559 readonly radiusY: number;
19560 readonly rotationAngle: number;
19561 readonly screenX: number;
19562 readonly screenY: number;
19563 readonly target: EventTarget | null;
19566 declare var Touch: {
19568 new(touchInitDict: TouchInit): Touch;
19569 isInstance: IsInstance<Touch>;
19572 interface TouchEvent extends UIEvent {
19573 readonly altKey: boolean;
19574 readonly changedTouches: TouchList;
19575 readonly ctrlKey: boolean;
19576 readonly metaKey: boolean;
19577 readonly shiftKey: boolean;
19578 readonly targetTouches: TouchList;
19579 readonly touches: TouchList;
19580 initTouchEvent(type: string, canBubble?: boolean, cancelable?: boolean, view?: Window | null, detail?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean, touches?: TouchList | null, targetTouches?: TouchList | null, changedTouches?: TouchList | null): void;
19583 declare var TouchEvent: {
19584 prototype: TouchEvent;
19585 new(type: string, eventInitDict?: TouchEventInit): TouchEvent;
19586 isInstance: IsInstance<TouchEvent>;
19589 interface TouchEventHandlersEventMap {
19590 "touchcancel": Event;
19592 "touchmove": Event;
19593 "touchstart": Event;
19596 interface TouchEventHandlers {
19597 ontouchcancel: ((this: TouchEventHandlers, ev: Event) => any) | null;
19598 ontouchend: ((this: TouchEventHandlers, ev: Event) => any) | null;
19599 ontouchmove: ((this: TouchEventHandlers, ev: Event) => any) | null;
19600 ontouchstart: ((this: TouchEventHandlers, ev: Event) => any) | null;
19601 addEventListener<K extends keyof TouchEventHandlersEventMap>(type: K, listener: (this: TouchEventHandlers, ev: TouchEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19602 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19603 removeEventListener<K extends keyof TouchEventHandlersEventMap>(type: K, listener: (this: TouchEventHandlers, ev: TouchEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19604 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19607 interface TouchList {
19608 readonly length: number;
19609 item(index: number): Touch | null;
19610 [index: number]: Touch;
19613 declare var TouchList: {
19614 prototype: TouchList;
19616 isInstance: IsInstance<TouchList>;
19619 interface TrackEvent extends Event {
19620 readonly track: VideoTrack | AudioTrack | TextTrack | null;
19623 declare var TrackEvent: {
19624 prototype: TrackEvent;
19625 new(type: string, eventInitDict?: TrackEventInit): TrackEvent;
19626 isInstance: IsInstance<TrackEvent>;
19629 interface TransformStream {
19630 readonly readable: ReadableStream;
19631 readonly writable: WritableStream;
19634 declare var TransformStream: {
19635 prototype: TransformStream;
19636 new(transformer?: any, writableStrategy?: QueuingStrategy, readableStrategy?: QueuingStrategy): TransformStream;
19637 isInstance: IsInstance<TransformStream>;
19640 interface TransformStreamDefaultController {
19641 readonly desiredSize: number | null;
19642 enqueue(chunk?: any): void;
19643 error(reason?: any): void;
19647 declare var TransformStreamDefaultController: {
19648 prototype: TransformStreamDefaultController;
19649 new(): TransformStreamDefaultController;
19650 isInstance: IsInstance<TransformStreamDefaultController>;
19653 interface TransitionEvent extends Event {
19654 readonly elapsedTime: number;
19655 readonly propertyName: string;
19656 readonly pseudoElement: string;
19659 declare var TransitionEvent: {
19660 prototype: TransitionEvent;
19661 new(type: string, eventInitDict?: TransitionEventInit): TransitionEvent;
19662 isInstance: IsInstance<TransitionEvent>;
19665 interface TreeColumn {
19666 readonly columns: TreeColumns | null;
19667 readonly cycler: boolean;
19668 readonly editable: boolean;
19669 readonly element: Element;
19670 readonly id: string;
19671 readonly index: number;
19672 readonly previousColumn: TreeColumn | null;
19673 readonly primary: boolean;
19674 readonly type: number;
19675 readonly width: number;
19676 readonly x: number;
19677 getNext(): TreeColumn | null;
19678 getPrevious(): TreeColumn | null;
19679 invalidate(): void;
19680 readonly TYPE_TEXT: 1;
19681 readonly TYPE_CHECKBOX: 2;
19684 declare var TreeColumn: {
19685 prototype: TreeColumn;
19687 readonly TYPE_TEXT: 1;
19688 readonly TYPE_CHECKBOX: 2;
19689 isInstance: IsInstance<TreeColumn>;
19692 interface TreeColumns {
19693 readonly count: number;
19694 readonly length: number;
19695 readonly tree: XULTreeElement | null;
19696 getColumnAt(index: number): TreeColumn | null;
19697 getColumnFor(element: Element | null): TreeColumn | null;
19698 getFirstColumn(): TreeColumn | null;
19699 getKeyColumn(): TreeColumn | null;
19700 getLastColumn(): TreeColumn | null;
19701 getNamedColumn(name: string): TreeColumn | null;
19702 getPrimaryColumn(): TreeColumn | null;
19703 getSortedColumn(): TreeColumn | null;
19704 invalidateColumns(): void;
19705 [index: number]: TreeColumn;
19708 declare var TreeColumns: {
19709 prototype: TreeColumns;
19710 new(): TreeColumns;
19711 isInstance: IsInstance<TreeColumns>;
19714 interface TreeContentView extends TreeView {
19715 getIndexOfItem(item: Element | null): number;
19716 getItemAtIndex(row: number): Element | null;
19719 declare var TreeContentView: {
19720 prototype: TreeContentView;
19721 new(): TreeContentView;
19722 readonly DROP_BEFORE: -1;
19723 readonly DROP_ON: 0;
19724 readonly DROP_AFTER: 1;
19725 isInstance: IsInstance<TreeContentView>;
19728 interface TreeView {
19729 readonly rowCount: number;
19730 selection: nsITreeSelection | null;
19731 canDrop(row: number, orientation: number, dataTransfer: DataTransfer | null): boolean;
19732 cycleCell(row: number, column: TreeColumn): void;
19733 cycleHeader(column: TreeColumn): void;
19734 drop(row: number, orientation: number, dataTransfer: DataTransfer | null): void;
19735 getCellProperties(row: number, column: TreeColumn): string;
19736 getCellText(row: number, column: TreeColumn): string;
19737 getCellValue(row: number, column: TreeColumn): string;
19738 getColumnProperties(column: TreeColumn): string;
19739 getImageSrc(row: number, column: TreeColumn): string;
19740 getLevel(row: number): number;
19741 getParentIndex(row: number): number;
19742 getRowProperties(row: number): string;
19743 hasNextSibling(row: number, afterIndex: number): boolean;
19744 isContainer(row: number): boolean;
19745 isContainerEmpty(row: number): boolean;
19746 isContainerOpen(row: number): boolean;
19747 isEditable(row: number, column: TreeColumn): boolean;
19748 isSeparator(row: number): boolean;
19749 isSorted(): boolean;
19750 selectionChanged(): void;
19751 setCellText(row: number, column: TreeColumn, value: string): void;
19752 setCellValue(row: number, column: TreeColumn, value: string): void;
19753 setTree(tree: XULTreeElement | null): void;
19754 toggleOpenState(row: number): void;
19755 readonly DROP_BEFORE: -1;
19756 readonly DROP_ON: 0;
19757 readonly DROP_AFTER: 1;
19760 interface TreeWalker {
19762 readonly filter: NodeFilter | null;
19763 readonly root: Node;
19764 readonly whatToShow: number;
19765 firstChild(): Node | null;
19766 lastChild(): Node | null;
19767 nextNode(): Node | null;
19768 nextSibling(): Node | null;
19769 parentNode(): Node | null;
19770 previousNode(): Node | null;
19771 previousSibling(): Node | null;
19774 declare var TreeWalker: {
19775 prototype: TreeWalker;
19777 isInstance: IsInstance<TreeWalker>;
19780 interface TrustedHTML {
19782 toString(): string;
19785 declare var TrustedHTML: {
19786 prototype: TrustedHTML;
19787 new(): TrustedHTML;
19788 isInstance: IsInstance<TrustedHTML>;
19791 interface TrustedScript {
19793 toString(): string;
19796 declare var TrustedScript: {
19797 prototype: TrustedScript;
19798 new(): TrustedScript;
19799 isInstance: IsInstance<TrustedScript>;
19802 interface TrustedScriptURL {
19804 toString(): string;
19807 declare var TrustedScriptURL: {
19808 prototype: TrustedScriptURL;
19809 new(): TrustedScriptURL;
19810 isInstance: IsInstance<TrustedScriptURL>;
19813 interface TrustedTypePolicy {
19814 readonly name: string;
19815 createHTML(input: string, ...arguments: any[]): TrustedHTML;
19816 createScript(input: string, ...arguments: any[]): TrustedScript;
19817 createScriptURL(input: string, ...arguments: any[]): TrustedScriptURL;
19820 declare var TrustedTypePolicy: {
19821 prototype: TrustedTypePolicy;
19822 new(): TrustedTypePolicy;
19823 isInstance: IsInstance<TrustedTypePolicy>;
19826 interface TrustedTypePolicyFactory {
19827 readonly defaultPolicy: TrustedTypePolicy | null;
19828 readonly emptyHTML: TrustedHTML;
19829 readonly emptyScript: TrustedScript;
19830 createPolicy(policyName: string, policyOptions?: TrustedTypePolicyOptions): TrustedTypePolicy;
19831 getAttributeType(tagName: string, attribute: string, elementNs?: string, attrNs?: string): string | null;
19832 getPropertyType(tagName: string, property: string, elementNs?: string): string | null;
19833 isHTML(value: any): boolean;
19834 isScript(value: any): boolean;
19835 isScriptURL(value: any): boolean;
19838 declare var TrustedTypePolicyFactory: {
19839 prototype: TrustedTypePolicyFactory;
19840 new(): TrustedTypePolicyFactory;
19841 isInstance: IsInstance<TrustedTypePolicyFactory>;
19844 interface UDPMessageEvent extends Event {
19845 readonly data: any;
19846 readonly remoteAddress: string;
19847 readonly remotePort: number;
19850 declare var UDPMessageEvent: {
19851 prototype: UDPMessageEvent;
19852 new(type: string, eventInitDict?: UDPMessageEventInit): UDPMessageEvent;
19853 isInstance: IsInstance<UDPMessageEvent>;
19856 interface UDPSocketEventMap {
19860 interface UDPSocket extends EventTarget {
19861 readonly addressReuse: boolean;
19862 readonly closed: Promise<undefined>;
19863 readonly localAddress: string | null;
19864 readonly localPort: number | null;
19865 readonly loopback: boolean;
19866 onmessage: ((this: UDPSocket, ev: Event) => any) | null;
19867 readonly opened: Promise<undefined>;
19868 readonly readyState: SocketReadyState;
19869 readonly remoteAddress: string | null;
19870 readonly remotePort: number | null;
19871 close(): Promise<void>;
19872 joinMulticastGroup(multicastGroupAddress: string): void;
19873 leaveMulticastGroup(multicastGroupAddress: string): void;
19874 send(data: string | Blob | ArrayBuffer | ArrayBufferView, remoteAddress?: string | null, remotePort?: number | null): boolean;
19875 addEventListener<K extends keyof UDPSocketEventMap>(type: K, listener: (this: UDPSocket, ev: UDPSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
19876 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
19877 removeEventListener<K extends keyof UDPSocketEventMap>(type: K, listener: (this: UDPSocket, ev: UDPSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
19878 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
19881 declare var UDPSocket: {
19882 prototype: UDPSocket;
19883 new(options?: UDPOptions): UDPSocket;
19884 isInstance: IsInstance<UDPSocket>;
19887 interface UIEvent extends Event {
19888 readonly detail: number;
19889 readonly layerX: number;
19890 readonly layerY: number;
19891 readonly rangeOffset: number;
19892 readonly rangeParent: Node | null;
19893 readonly view: WindowProxy | null;
19894 readonly which: number;
19895 initUIEvent(aType: string, aCanBubble?: boolean, aCancelable?: boolean, aView?: Window | null, aDetail?: number): void;
19896 readonly SCROLL_PAGE_UP: -32768;
19897 readonly SCROLL_PAGE_DOWN: 32768;
19900 declare var UIEvent: {
19901 prototype: UIEvent;
19902 new(type: string, eventInitDict?: UIEventInit): UIEvent;
19903 readonly SCROLL_PAGE_UP: -32768;
19904 readonly SCROLL_PAGE_DOWN: 32768;
19905 isInstance: IsInstance<UIEvent>;
19917 toString(): string;
19918 readonly origin: string;
19924 readonly searchParams: URLSearchParams;
19931 new(url: string, base?: string): URL;
19932 isInstance: IsInstance<URL>;
19933 canParse(url: string, base?: string): boolean;
19934 createObjectURL(blob: Blob): string;
19935 createObjectURL(source: MediaSource): string;
19936 fromURI(uri: URI): URL;
19937 isValidObjectURL(url: string): boolean;
19938 parse(url: string, base?: string): URL | null;
19939 revokeObjectURL(url: string): void;
19942 type webkitURL = URL;
19943 declare var webkitURL: typeof URL;
19945 interface URLSearchParams {
19946 readonly size: number;
19947 append(name: string, value: string): void;
19948 delete(name: string, value?: string): void;
19949 get(name: string): string | null;
19950 getAll(name: string): string[];
19951 has(name: string, value?: string): boolean;
19952 set(name: string, value: string): void;
19954 toString(): string;
19955 forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
19958 declare var URLSearchParams: {
19959 prototype: URLSearchParams;
19960 new(init?: string[][] | Record<string, string> | string): URLSearchParams;
19961 isInstance: IsInstance<URLSearchParams>;
19964 interface UniFFIPointer {
19967 declare var UniFFIPointer: {
19968 prototype: UniFFIPointer;
19969 new(): UniFFIPointer;
19970 isInstance: IsInstance<UniFFIPointer>;
19973 interface UserActivation {
19974 readonly hasBeenActive: boolean;
19975 readonly isActive: boolean;
19978 declare var UserActivation: {
19979 prototype: UserActivation;
19980 new(): UserActivation;
19981 isInstance: IsInstance<UserActivation>;
19984 interface UserProximityEvent extends Event {
19985 readonly near: boolean;
19988 declare var UserProximityEvent: {
19989 prototype: UserProximityEvent;
19990 new(type: string, eventInitDict?: UserProximityEventInit): UserProximityEvent;
19991 isInstance: IsInstance<UserProximityEvent>;
19994 /** Available only in secure contexts. */
19995 interface VRDisplay extends EventTarget {
19996 readonly capabilities: VRDisplayCapabilities;
19999 readonly displayId: number;
20000 readonly displayName: string;
20002 readonly isConnected: boolean;
20003 readonly isPresenting: boolean;
20004 readonly presentingGroups: number;
20005 readonly stageParameters: VRStageParameters | null;
20006 cancelAnimationFrame(handle: number): void;
20007 exitPresent(): Promise<void>;
20008 getEyeParameters(whichEye: VREye): VREyeParameters;
20009 getFrameData(frameData: VRFrameData): boolean;
20010 getLayers(): VRLayer[];
20012 requestAnimationFrame(callback: FrameRequestCallback): number;
20013 requestPresent(layers: VRLayer[]): Promise<void>;
20015 submitFrame(): void;
20018 declare var VRDisplay: {
20019 prototype: VRDisplay;
20021 isInstance: IsInstance<VRDisplay>;
20024 /** Available only in secure contexts. */
20025 interface VRDisplayCapabilities {
20026 readonly canPresent: boolean;
20027 readonly hasExternalDisplay: boolean;
20028 readonly hasOrientation: boolean;
20029 readonly hasPosition: boolean;
20030 readonly maxLayers: number;
20033 declare var VRDisplayCapabilities: {
20034 prototype: VRDisplayCapabilities;
20035 new(): VRDisplayCapabilities;
20036 isInstance: IsInstance<VRDisplayCapabilities>;
20039 /** Available only in secure contexts. */
20040 interface VRDisplayEvent extends Event {
20041 readonly display: VRDisplay;
20042 readonly reason: VRDisplayEventReason | null;
20045 declare var VRDisplayEvent: {
20046 prototype: VRDisplayEvent;
20047 new(type: string, eventInitDict: VRDisplayEventInit): VRDisplayEvent;
20048 isInstance: IsInstance<VRDisplayEvent>;
20051 /** Available only in secure contexts. */
20052 interface VREyeParameters {
20053 readonly fieldOfView: VRFieldOfView;
20054 readonly offset: Float32Array;
20055 readonly renderHeight: number;
20056 readonly renderWidth: number;
20059 declare var VREyeParameters: {
20060 prototype: VREyeParameters;
20061 new(): VREyeParameters;
20062 isInstance: IsInstance<VREyeParameters>;
20065 /** Available only in secure contexts. */
20066 interface VRFieldOfView {
20067 readonly downDegrees: number;
20068 readonly leftDegrees: number;
20069 readonly rightDegrees: number;
20070 readonly upDegrees: number;
20073 declare var VRFieldOfView: {
20074 prototype: VRFieldOfView;
20075 new(): VRFieldOfView;
20076 isInstance: IsInstance<VRFieldOfView>;
20079 /** Available only in secure contexts. */
20080 interface VRFrameData {
20081 readonly leftProjectionMatrix: Float32Array;
20082 readonly leftViewMatrix: Float32Array;
20083 readonly pose: VRPose;
20084 readonly rightProjectionMatrix: Float32Array;
20085 readonly rightViewMatrix: Float32Array;
20086 readonly timestamp: DOMHighResTimeStamp;
20089 declare var VRFrameData: {
20090 prototype: VRFrameData;
20091 new(): VRFrameData;
20092 isInstance: IsInstance<VRFrameData>;
20095 interface VRMockController {
20097 buttonCount: number;
20098 capAngularAcceleration: boolean;
20099 capLinearAcceleration: boolean;
20100 capOrientation: boolean;
20101 capPosition: boolean;
20103 hapticCount: number;
20106 setAxisValue(axisIdx: number, value: number): void;
20107 setButtonPressed(buttonIdx: number, pressed: boolean): void;
20108 setButtonTouched(buttonIdx: number, touched: boolean): void;
20109 setButtonTrigger(buttonIdx: number, trigger: number): void;
20110 setPose(position: Float32Array | null, linearVelocity: Float32Array | null, linearAcceleration: Float32Array | null, orientation: Float32Array | null, angularVelocity: Float32Array | null, angularAcceleration: Float32Array | null): void;
20113 declare var VRMockController: {
20114 prototype: VRMockController;
20115 new(): VRMockController;
20116 isInstance: IsInstance<VRMockController>;
20119 interface VRMockDisplay {
20120 capAngularAcceleration: boolean;
20121 capExternal: boolean;
20122 capLinearAcceleration: boolean;
20123 capMountDetection: boolean;
20124 capOrientation: boolean;
20125 capPosition: boolean;
20126 capPositionEmulated: boolean;
20127 capPresent: boolean;
20128 capStageParameters: boolean;
20130 setConnected(connected: boolean): void;
20131 setEyeFOV(eye: VREye, upDegree: number, rightDegree: number, downDegree: number, leftDegree: number): void;
20132 setEyeOffset(eye: VREye, offsetX: number, offsetY: number, offsetZ: number): void;
20133 setEyeResolution(renderWidth: number, renderHeight: number): void;
20134 setMounted(mounted: boolean): void;
20135 setPose(position: Float32Array | null, linearVelocity: Float32Array | null, linearAcceleration: Float32Array | null, orientation: Float32Array | null, angularVelocity: Float32Array | null, angularAcceleration: Float32Array | null): void;
20136 setSittingToStandingTransform(sittingToStandingTransform: Float32Array): void;
20137 setStageSize(width: number, height: number): void;
20140 declare var VRMockDisplay: {
20141 prototype: VRMockDisplay;
20142 new(): VRMockDisplay;
20143 isInstance: IsInstance<VRMockDisplay>;
20146 /** Available only in secure contexts. */
20148 readonly angularAcceleration: Float32Array | null;
20149 readonly angularVelocity: Float32Array | null;
20150 readonly linearAcceleration: Float32Array | null;
20151 readonly linearVelocity: Float32Array | null;
20152 readonly orientation: Float32Array | null;
20153 readonly position: Float32Array | null;
20156 declare var VRPose: {
20159 isInstance: IsInstance<VRPose>;
20162 interface VRServiceTest {
20163 acknowledgeFrame(): void;
20164 captureFrame(): void;
20168 getVRController(controllerIdx: number): VRMockController;
20169 getVRDisplay(): VRMockDisplay;
20170 rejectFrame(): void;
20171 reset(): Promise<void>;
20172 run(): Promise<void>;
20173 startTimer(): void;
20175 timeout(duration: number): void;
20176 wait(duration: number): void;
20177 waitHapticIntensity(controllerIdx: number, hapticIdx: number, intensity: number): void;
20178 waitPresentationEnd(): void;
20179 waitPresentationStart(): void;
20180 waitSubmit(): void;
20183 declare var VRServiceTest: {
20184 prototype: VRServiceTest;
20185 new(): VRServiceTest;
20186 isInstance: IsInstance<VRServiceTest>;
20189 /** Available only in secure contexts. */
20190 interface VRStageParameters {
20191 readonly sittingToStandingTransform: Float32Array;
20192 readonly sizeX: number;
20193 readonly sizeZ: number;
20196 declare var VRStageParameters: {
20197 prototype: VRStageParameters;
20198 new(): VRStageParameters;
20199 isInstance: IsInstance<VRStageParameters>;
20202 interface VTTCue extends TextTrackCue {
20203 align: AlignSetting;
20204 readonly computedLine: number;
20205 readonly computedPosition: number;
20206 readonly computedPositionAlign: PositionAlignSetting;
20207 displayState: HTMLDivElement | null;
20208 readonly getActive: boolean;
20209 readonly hasBeenReset: boolean;
20210 line: number | AutoKeyword;
20211 lineAlign: LineAlignSetting;
20212 position: number | AutoKeyword;
20213 positionAlign: PositionAlignSetting;
20214 region: VTTRegion | null;
20216 snapToLines: boolean;
20218 vertical: DirectionSetting;
20219 getCueAsHTML(): DocumentFragment;
20220 addEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20221 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20222 removeEventListener<K extends keyof TextTrackCueEventMap>(type: K, listener: (this: VTTCue, ev: TextTrackCueEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20223 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20226 declare var VTTCue: {
20228 new(startTime: number, endTime: number, text: string): VTTCue;
20229 isInstance: IsInstance<VTTCue>;
20232 interface VTTRegion {
20235 regionAnchorX: number;
20236 regionAnchorY: number;
20237 scroll: ScrollSetting;
20238 viewportAnchorX: number;
20239 viewportAnchorY: number;
20243 declare var VTTRegion: {
20244 prototype: VTTRegion;
20246 isInstance: IsInstance<VTTRegion>;
20249 interface ValidityState {
20250 readonly badInput: boolean;
20251 readonly customError: boolean;
20252 readonly patternMismatch: boolean;
20253 readonly rangeOverflow: boolean;
20254 readonly rangeUnderflow: boolean;
20255 readonly stepMismatch: boolean;
20256 readonly tooLong: boolean;
20257 readonly tooShort: boolean;
20258 readonly typeMismatch: boolean;
20259 readonly valid: boolean;
20260 readonly valueMissing: boolean;
20263 declare var ValidityState: {
20264 prototype: ValidityState;
20265 new(): ValidityState;
20266 isInstance: IsInstance<ValidityState>;
20269 interface VideoColorSpace {
20270 readonly fullRange: boolean | null;
20271 readonly matrix: VideoMatrixCoefficients | null;
20272 readonly primaries: VideoColorPrimaries | null;
20273 readonly transfer: VideoTransferCharacteristics | null;
20277 declare var VideoColorSpace: {
20278 prototype: VideoColorSpace;
20279 new(init?: VideoColorSpaceInit): VideoColorSpace;
20280 isInstance: IsInstance<VideoColorSpace>;
20283 interface VideoDecoderEventMap {
20287 /** Available only in secure contexts. */
20288 interface VideoDecoder extends EventTarget {
20289 readonly decodeQueueSize: number;
20290 ondequeue: ((this: VideoDecoder, ev: Event) => any) | null;
20291 readonly state: CodecState;
20293 configure(config: VideoDecoderConfig): void;
20294 decode(chunk: EncodedVideoChunk): void;
20295 flush(): Promise<void>;
20297 addEventListener<K extends keyof VideoDecoderEventMap>(type: K, listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20298 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20299 removeEventListener<K extends keyof VideoDecoderEventMap>(type: K, listener: (this: VideoDecoder, ev: VideoDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20300 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20303 declare var VideoDecoder: {
20304 prototype: VideoDecoder;
20305 new(init: VideoDecoderInit): VideoDecoder;
20306 isInstance: IsInstance<VideoDecoder>;
20307 isConfigSupported(config: VideoDecoderConfig): Promise<VideoDecoderSupport>;
20310 interface VideoEncoderEventMap {
20314 /** Available only in secure contexts. */
20315 interface VideoEncoder extends EventTarget {
20316 readonly encodeQueueSize: number;
20317 ondequeue: ((this: VideoEncoder, ev: Event) => any) | null;
20318 readonly state: CodecState;
20320 configure(config: VideoEncoderConfig): void;
20321 encode(frame: VideoFrame, options?: VideoEncoderEncodeOptions): void;
20322 flush(): Promise<void>;
20324 addEventListener<K extends keyof VideoEncoderEventMap>(type: K, listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20325 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20326 removeEventListener<K extends keyof VideoEncoderEventMap>(type: K, listener: (this: VideoEncoder, ev: VideoEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20327 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20330 declare var VideoEncoder: {
20331 prototype: VideoEncoder;
20332 new(init: VideoEncoderInit): VideoEncoder;
20333 isInstance: IsInstance<VideoEncoder>;
20334 isConfigSupported(config: VideoEncoderConfig): Promise<VideoEncoderSupport>;
20337 interface VideoFrame {
20338 readonly codedHeight: number;
20339 readonly codedRect: DOMRectReadOnly | null;
20340 readonly codedWidth: number;
20341 readonly colorSpace: VideoColorSpace;
20342 readonly displayHeight: number;
20343 readonly displayWidth: number;
20344 readonly duration: number | null;
20345 readonly format: VideoPixelFormat | null;
20346 readonly timestamp: number;
20347 readonly visibleRect: DOMRectReadOnly | null;
20348 allocationSize(options?: VideoFrameCopyToOptions): number;
20349 clone(): VideoFrame;
20351 copyTo(destination: ArrayBufferView | ArrayBuffer, options?: VideoFrameCopyToOptions): Promise<PlaneLayout[]>;
20354 declare var VideoFrame: {
20355 prototype: VideoFrame;
20356 new(imageElement: HTMLImageElement, init?: VideoFrameInit): VideoFrame;
20357 new(svgImageElement: SVGImageElement, init?: VideoFrameInit): VideoFrame;
20358 new(canvasElement: HTMLCanvasElement, init?: VideoFrameInit): VideoFrame;
20359 new(videoElement: HTMLVideoElement, init?: VideoFrameInit): VideoFrame;
20360 new(offscreenCanvas: OffscreenCanvas, init?: VideoFrameInit): VideoFrame;
20361 new(imageBitmap: ImageBitmap, init?: VideoFrameInit): VideoFrame;
20362 new(videoFrame: VideoFrame, init?: VideoFrameInit): VideoFrame;
20363 new(bufferView: ArrayBufferView, init: VideoFrameBufferInit): VideoFrame;
20364 new(buffer: ArrayBuffer, init: VideoFrameBufferInit): VideoFrame;
20365 isInstance: IsInstance<VideoFrame>;
20368 interface VideoPlaybackQuality {
20369 readonly creationTime: DOMHighResTimeStamp;
20370 readonly droppedVideoFrames: number;
20371 readonly totalVideoFrames: number;
20374 declare var VideoPlaybackQuality: {
20375 prototype: VideoPlaybackQuality;
20376 new(): VideoPlaybackQuality;
20377 isInstance: IsInstance<VideoPlaybackQuality>;
20380 interface VideoTrack {
20381 readonly id: string;
20382 readonly kind: string;
20383 readonly label: string;
20384 readonly language: string;
20388 declare var VideoTrack: {
20389 prototype: VideoTrack;
20391 isInstance: IsInstance<VideoTrack>;
20394 interface VideoTrackListEventMap {
20397 "removetrack": Event;
20400 interface VideoTrackList extends EventTarget {
20401 readonly length: number;
20402 onaddtrack: ((this: VideoTrackList, ev: Event) => any) | null;
20403 onchange: ((this: VideoTrackList, ev: Event) => any) | null;
20404 onremovetrack: ((this: VideoTrackList, ev: Event) => any) | null;
20405 readonly selectedIndex: number;
20406 getTrackById(id: string): VideoTrack | null;
20407 addEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20408 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20409 removeEventListener<K extends keyof VideoTrackListEventMap>(type: K, listener: (this: VideoTrackList, ev: VideoTrackListEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20410 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20411 [index: number]: VideoTrack;
20414 declare var VideoTrackList: {
20415 prototype: VideoTrackList;
20416 new(): VideoTrackList;
20417 isInstance: IsInstance<VideoTrackList>;
20420 interface VisualViewportEventMap {
20425 interface VisualViewport extends EventTarget {
20426 readonly height: number;
20427 readonly offsetLeft: number;
20428 readonly offsetTop: number;
20429 onresize: ((this: VisualViewport, ev: Event) => any) | null;
20430 onscroll: ((this: VisualViewport, ev: Event) => any) | null;
20431 readonly pageLeft: number;
20432 readonly pageTop: number;
20433 readonly scale: number;
20434 readonly width: number;
20435 addEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20436 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20437 removeEventListener<K extends keyof VisualViewportEventMap>(type: K, listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20438 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20441 declare var VisualViewport: {
20442 prototype: VisualViewport;
20443 new(): VisualViewport;
20444 isInstance: IsInstance<VisualViewport>;
20447 interface WEBGL_color_buffer_float {
20448 readonly RGBA32F_EXT: 0x8814;
20449 readonly RGB32F_EXT: 0x8815;
20450 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT: 0x8211;
20451 readonly UNSIGNED_NORMALIZED_EXT: 0x8C17;
20454 interface WEBGL_compressed_texture_astc {
20455 getSupportedProfiles(): string[] | null;
20456 readonly COMPRESSED_RGBA_ASTC_4x4_KHR: 0x93B0;
20457 readonly COMPRESSED_RGBA_ASTC_5x4_KHR: 0x93B1;
20458 readonly COMPRESSED_RGBA_ASTC_5x5_KHR: 0x93B2;
20459 readonly COMPRESSED_RGBA_ASTC_6x5_KHR: 0x93B3;
20460 readonly COMPRESSED_RGBA_ASTC_6x6_KHR: 0x93B4;
20461 readonly COMPRESSED_RGBA_ASTC_8x5_KHR: 0x93B5;
20462 readonly COMPRESSED_RGBA_ASTC_8x6_KHR: 0x93B6;
20463 readonly COMPRESSED_RGBA_ASTC_8x8_KHR: 0x93B7;
20464 readonly COMPRESSED_RGBA_ASTC_10x5_KHR: 0x93B8;
20465 readonly COMPRESSED_RGBA_ASTC_10x6_KHR: 0x93B9;
20466 readonly COMPRESSED_RGBA_ASTC_10x8_KHR: 0x93BA;
20467 readonly COMPRESSED_RGBA_ASTC_10x10_KHR: 0x93BB;
20468 readonly COMPRESSED_RGBA_ASTC_12x10_KHR: 0x93BC;
20469 readonly COMPRESSED_RGBA_ASTC_12x12_KHR: 0x93BD;
20470 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 0x93D0;
20471 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 0x93D1;
20472 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 0x93D2;
20473 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 0x93D3;
20474 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 0x93D4;
20475 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 0x93D5;
20476 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 0x93D6;
20477 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 0x93D7;
20478 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 0x93D8;
20479 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 0x93D9;
20480 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 0x93DA;
20481 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 0x93DB;
20482 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 0x93DC;
20483 readonly COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 0x93DD;
20486 interface WEBGL_compressed_texture_etc {
20487 readonly COMPRESSED_R11_EAC: 0x9270;
20488 readonly COMPRESSED_SIGNED_R11_EAC: 0x9271;
20489 readonly COMPRESSED_RG11_EAC: 0x9272;
20490 readonly COMPRESSED_SIGNED_RG11_EAC: 0x9273;
20491 readonly COMPRESSED_RGB8_ETC2: 0x9274;
20492 readonly COMPRESSED_SRGB8_ETC2: 0x9275;
20493 readonly COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 0x9276;
20494 readonly COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 0x9277;
20495 readonly COMPRESSED_RGBA8_ETC2_EAC: 0x9278;
20496 readonly COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 0x9279;
20499 interface WEBGL_compressed_texture_etc1 {
20500 readonly COMPRESSED_RGB_ETC1_WEBGL: 0x8D64;
20503 interface WEBGL_compressed_texture_pvrtc {
20504 readonly COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 0x8C00;
20505 readonly COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 0x8C01;
20506 readonly COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 0x8C02;
20507 readonly COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 0x8C03;
20510 interface WEBGL_compressed_texture_s3tc {
20511 readonly COMPRESSED_RGB_S3TC_DXT1_EXT: 0x83F0;
20512 readonly COMPRESSED_RGBA_S3TC_DXT1_EXT: 0x83F1;
20513 readonly COMPRESSED_RGBA_S3TC_DXT3_EXT: 0x83F2;
20514 readonly COMPRESSED_RGBA_S3TC_DXT5_EXT: 0x83F3;
20517 interface WEBGL_compressed_texture_s3tc_srgb {
20518 readonly COMPRESSED_SRGB_S3TC_DXT1_EXT: 0x8C4C;
20519 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 0x8C4D;
20520 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 0x8C4E;
20521 readonly COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 0x8C4F;
20524 interface WEBGL_debug_renderer_info {
20525 readonly UNMASKED_VENDOR_WEBGL: 0x9245;
20526 readonly UNMASKED_RENDERER_WEBGL: 0x9246;
20529 interface WEBGL_debug_shaders {
20530 getTranslatedShaderSource(shader: WebGLShader): string;
20533 interface WEBGL_depth_texture {
20534 readonly UNSIGNED_INT_24_8_WEBGL: 0x84FA;
20537 interface WEBGL_draw_buffers {
20538 drawBuffersWEBGL(buffers: GLenum[]): void;
20539 readonly COLOR_ATTACHMENT0_WEBGL: 0x8CE0;
20540 readonly COLOR_ATTACHMENT1_WEBGL: 0x8CE1;
20541 readonly COLOR_ATTACHMENT2_WEBGL: 0x8CE2;
20542 readonly COLOR_ATTACHMENT3_WEBGL: 0x8CE3;
20543 readonly COLOR_ATTACHMENT4_WEBGL: 0x8CE4;
20544 readonly COLOR_ATTACHMENT5_WEBGL: 0x8CE5;
20545 readonly COLOR_ATTACHMENT6_WEBGL: 0x8CE6;
20546 readonly COLOR_ATTACHMENT7_WEBGL: 0x8CE7;
20547 readonly COLOR_ATTACHMENT8_WEBGL: 0x8CE8;
20548 readonly COLOR_ATTACHMENT9_WEBGL: 0x8CE9;
20549 readonly COLOR_ATTACHMENT10_WEBGL: 0x8CEA;
20550 readonly COLOR_ATTACHMENT11_WEBGL: 0x8CEB;
20551 readonly COLOR_ATTACHMENT12_WEBGL: 0x8CEC;
20552 readonly COLOR_ATTACHMENT13_WEBGL: 0x8CED;
20553 readonly COLOR_ATTACHMENT14_WEBGL: 0x8CEE;
20554 readonly COLOR_ATTACHMENT15_WEBGL: 0x8CEF;
20555 readonly DRAW_BUFFER0_WEBGL: 0x8825;
20556 readonly DRAW_BUFFER1_WEBGL: 0x8826;
20557 readonly DRAW_BUFFER2_WEBGL: 0x8827;
20558 readonly DRAW_BUFFER3_WEBGL: 0x8828;
20559 readonly DRAW_BUFFER4_WEBGL: 0x8829;
20560 readonly DRAW_BUFFER5_WEBGL: 0x882A;
20561 readonly DRAW_BUFFER6_WEBGL: 0x882B;
20562 readonly DRAW_BUFFER7_WEBGL: 0x882C;
20563 readonly DRAW_BUFFER8_WEBGL: 0x882D;
20564 readonly DRAW_BUFFER9_WEBGL: 0x882E;
20565 readonly DRAW_BUFFER10_WEBGL: 0x882F;
20566 readonly DRAW_BUFFER11_WEBGL: 0x8830;
20567 readonly DRAW_BUFFER12_WEBGL: 0x8831;
20568 readonly DRAW_BUFFER13_WEBGL: 0x8832;
20569 readonly DRAW_BUFFER14_WEBGL: 0x8833;
20570 readonly DRAW_BUFFER15_WEBGL: 0x8834;
20571 readonly MAX_COLOR_ATTACHMENTS_WEBGL: 0x8CDF;
20572 readonly MAX_DRAW_BUFFERS_WEBGL: 0x8824;
20575 interface WEBGL_explicit_present {
20579 interface WEBGL_lose_context {
20580 loseContext(): void;
20581 restoreContext(): void;
20584 interface WEBGL_provoking_vertex {
20585 provokingVertexWEBGL(provokeMode: GLenum): void;
20586 readonly FIRST_VERTEX_CONVENTION_WEBGL: 0x8E4D;
20587 readonly LAST_VERTEX_CONVENTION_WEBGL: 0x8E4E;
20588 readonly PROVOKING_VERTEX_WEBGL: 0x8E4F;
20591 /** Available only in secure contexts. */
20592 interface WakeLock {
20593 request(type?: WakeLockType): Promise<WakeLockSentinel>;
20596 declare var WakeLock: {
20597 prototype: WakeLock;
20599 isInstance: IsInstance<WakeLock>;
20602 interface WakeLockSentinelEventMap {
20606 /** Available only in secure contexts. */
20607 interface WakeLockSentinel extends EventTarget {
20608 onrelease: ((this: WakeLockSentinel, ev: Event) => any) | null;
20609 readonly released: boolean;
20610 readonly type: WakeLockType;
20611 release(): Promise<void>;
20612 addEventListener<K extends keyof WakeLockSentinelEventMap>(type: K, listener: (this: WakeLockSentinel, ev: WakeLockSentinelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
20613 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
20614 removeEventListener<K extends keyof WakeLockSentinelEventMap>(type: K, listener: (this: WakeLockSentinel, ev: WakeLockSentinelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
20615 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
20618 declare var WakeLockSentinel: {
20619 prototype: WakeLockSentinel;
20620 new(): WakeLockSentinel;
20621 isInstance: IsInstance<WakeLockSentinel>;
20624 interface WaveShaperNode extends AudioNode, AudioNodePassThrough {
20625 curve: Float32Array | null;
20626 oversample: OverSampleType;
20629 declare var WaveShaperNode: {
20630 prototype: WaveShaperNode;
20631 new(context: BaseAudioContext, options?: WaveShaperOptions): WaveShaperNode;
20632 isInstance: IsInstance<WaveShaperNode>;
20635 interface WebBrowserPersistable {
20636 startPersistence(aContext: BrowsingContext | null, aRecv: nsIWebBrowserPersistDocumentReceiver): void;
20639 interface WebExtensionContentScript extends MozDocumentMatcher {
20640 readonly cssPaths: string[];
20641 readonly jsPaths: string[];
20642 readonly runAt: ContentScriptRunAt;
20643 readonly world: ContentScriptExecutionWorld;
20646 declare var WebExtensionContentScript: {
20647 prototype: WebExtensionContentScript;
20648 new(extension: WebExtensionPolicy, options: WebExtensionContentScriptInit): WebExtensionContentScript;
20649 isInstance: IsInstance<WebExtensionContentScript>;
20652 interface WebExtensionPolicy {
20654 allowedOrigins: MatchPatternSet;
20655 readonly baseCSP: string;
20656 readonly baseURL: string;
20657 readonly browsingContextGroupId: number;
20658 readonly contentScripts: WebExtensionContentScript[];
20659 readonly extensionPageCSP: string;
20660 readonly id: string;
20661 ignoreQuarantine: boolean;
20662 readonly isPrivileged: boolean;
20663 readonly manifestVersion: number;
20664 readonly mozExtensionHostname: string;
20665 readonly name: string;
20666 permissions: string[];
20667 readonly privateBrowsingAllowed: boolean;
20668 readonly readyPromise: any;
20669 readonly temporarilyInstalled: boolean;
20670 readonly type: string;
20671 canAccessURI(uri: URI, explicit?: boolean): boolean;
20672 canAccessWindow(window: WindowProxy): boolean;
20673 getURL(path?: string): string;
20674 hasPermission(permission: string): boolean;
20675 injectContentScripts(): void;
20676 isManifestBackgroundWorker(workerURL: string): boolean;
20677 isWebAccessiblePath(pathname: string): boolean;
20678 localize(unlocalizedText: string): string;
20679 quarantinedFromURI(uri: URI): boolean;
20680 registerContentScript(script: WebExtensionContentScript): void;
20681 sourceMayAccessPath(sourceURI: URI, pathname: string): boolean;
20682 unregisterContentScript(script: WebExtensionContentScript): void;
20685 declare var WebExtensionPolicy: {
20686 prototype: WebExtensionPolicy;
20687 new(options: WebExtensionInit): WebExtensionPolicy;
20688 readonly backgroundServiceWorkerEnabled: boolean;
20689 readonly isExtensionProcess: boolean;
20690 isInstance: IsInstance<WebExtensionPolicy>;
20691 readonly quarantinedDomainsEnabled: boolean;
20692 readonly useRemoteWebExtensions: boolean;
20693 getActiveExtensions(): WebExtensionPolicy[];
20694 getByHostname(hostname: string): WebExtensionPolicy | null;
20695 getByID(id: string): WebExtensionPolicy | null;
20696 getByURI(uri: URI): WebExtensionPolicy | null;
20697 isQuarantinedURI(uri: URI): boolean;
20698 isRestrictedURI(uri: URI): boolean;
20701 interface WebGL2RenderingContext extends WebGL2RenderingContextBase, WebGLRenderingContextBase {
20704 declare var WebGL2RenderingContext: {
20705 prototype: WebGL2RenderingContext;
20706 new(): WebGL2RenderingContext;
20707 readonly READ_BUFFER: 0x0C02;
20708 readonly UNPACK_ROW_LENGTH: 0x0CF2;
20709 readonly UNPACK_SKIP_ROWS: 0x0CF3;
20710 readonly UNPACK_SKIP_PIXELS: 0x0CF4;
20711 readonly PACK_ROW_LENGTH: 0x0D02;
20712 readonly PACK_SKIP_ROWS: 0x0D03;
20713 readonly PACK_SKIP_PIXELS: 0x0D04;
20714 readonly COLOR: 0x1800;
20715 readonly DEPTH: 0x1801;
20716 readonly STENCIL: 0x1802;
20717 readonly RED: 0x1903;
20718 readonly RGB8: 0x8051;
20719 readonly RGBA8: 0x8058;
20720 readonly RGB10_A2: 0x8059;
20721 readonly TEXTURE_BINDING_3D: 0x806A;
20722 readonly UNPACK_SKIP_IMAGES: 0x806D;
20723 readonly UNPACK_IMAGE_HEIGHT: 0x806E;
20724 readonly TEXTURE_3D: 0x806F;
20725 readonly TEXTURE_WRAP_R: 0x8072;
20726 readonly MAX_3D_TEXTURE_SIZE: 0x8073;
20727 readonly UNSIGNED_INT_2_10_10_10_REV: 0x8368;
20728 readonly MAX_ELEMENTS_VERTICES: 0x80E8;
20729 readonly MAX_ELEMENTS_INDICES: 0x80E9;
20730 readonly TEXTURE_MIN_LOD: 0x813A;
20731 readonly TEXTURE_MAX_LOD: 0x813B;
20732 readonly TEXTURE_BASE_LEVEL: 0x813C;
20733 readonly TEXTURE_MAX_LEVEL: 0x813D;
20734 readonly MIN: 0x8007;
20735 readonly MAX: 0x8008;
20736 readonly DEPTH_COMPONENT24: 0x81A6;
20737 readonly MAX_TEXTURE_LOD_BIAS: 0x84FD;
20738 readonly TEXTURE_COMPARE_MODE: 0x884C;
20739 readonly TEXTURE_COMPARE_FUNC: 0x884D;
20740 readonly CURRENT_QUERY: 0x8865;
20741 readonly QUERY_RESULT: 0x8866;
20742 readonly QUERY_RESULT_AVAILABLE: 0x8867;
20743 readonly STREAM_READ: 0x88E1;
20744 readonly STREAM_COPY: 0x88E2;
20745 readonly STATIC_READ: 0x88E5;
20746 readonly STATIC_COPY: 0x88E6;
20747 readonly DYNAMIC_READ: 0x88E9;
20748 readonly DYNAMIC_COPY: 0x88EA;
20749 readonly MAX_DRAW_BUFFERS: 0x8824;
20750 readonly DRAW_BUFFER0: 0x8825;
20751 readonly DRAW_BUFFER1: 0x8826;
20752 readonly DRAW_BUFFER2: 0x8827;
20753 readonly DRAW_BUFFER3: 0x8828;
20754 readonly DRAW_BUFFER4: 0x8829;
20755 readonly DRAW_BUFFER5: 0x882A;
20756 readonly DRAW_BUFFER6: 0x882B;
20757 readonly DRAW_BUFFER7: 0x882C;
20758 readonly DRAW_BUFFER8: 0x882D;
20759 readonly DRAW_BUFFER9: 0x882E;
20760 readonly DRAW_BUFFER10: 0x882F;
20761 readonly DRAW_BUFFER11: 0x8830;
20762 readonly DRAW_BUFFER12: 0x8831;
20763 readonly DRAW_BUFFER13: 0x8832;
20764 readonly DRAW_BUFFER14: 0x8833;
20765 readonly DRAW_BUFFER15: 0x8834;
20766 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: 0x8B49;
20767 readonly MAX_VERTEX_UNIFORM_COMPONENTS: 0x8B4A;
20768 readonly SAMPLER_3D: 0x8B5F;
20769 readonly SAMPLER_2D_SHADOW: 0x8B62;
20770 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: 0x8B8B;
20771 readonly PIXEL_PACK_BUFFER: 0x88EB;
20772 readonly PIXEL_UNPACK_BUFFER: 0x88EC;
20773 readonly PIXEL_PACK_BUFFER_BINDING: 0x88ED;
20774 readonly PIXEL_UNPACK_BUFFER_BINDING: 0x88EF;
20775 readonly FLOAT_MAT2x3: 0x8B65;
20776 readonly FLOAT_MAT2x4: 0x8B66;
20777 readonly FLOAT_MAT3x2: 0x8B67;
20778 readonly FLOAT_MAT3x4: 0x8B68;
20779 readonly FLOAT_MAT4x2: 0x8B69;
20780 readonly FLOAT_MAT4x3: 0x8B6A;
20781 readonly SRGB: 0x8C40;
20782 readonly SRGB8: 0x8C41;
20783 readonly SRGB8_ALPHA8: 0x8C43;
20784 readonly COMPARE_REF_TO_TEXTURE: 0x884E;
20785 readonly RGBA32F: 0x8814;
20786 readonly RGB32F: 0x8815;
20787 readonly RGBA16F: 0x881A;
20788 readonly RGB16F: 0x881B;
20789 readonly VERTEX_ATTRIB_ARRAY_INTEGER: 0x88FD;
20790 readonly MAX_ARRAY_TEXTURE_LAYERS: 0x88FF;
20791 readonly MIN_PROGRAM_TEXEL_OFFSET: 0x8904;
20792 readonly MAX_PROGRAM_TEXEL_OFFSET: 0x8905;
20793 readonly MAX_VARYING_COMPONENTS: 0x8B4B;
20794 readonly TEXTURE_2D_ARRAY: 0x8C1A;
20795 readonly TEXTURE_BINDING_2D_ARRAY: 0x8C1D;
20796 readonly R11F_G11F_B10F: 0x8C3A;
20797 readonly UNSIGNED_INT_10F_11F_11F_REV: 0x8C3B;
20798 readonly RGB9_E5: 0x8C3D;
20799 readonly UNSIGNED_INT_5_9_9_9_REV: 0x8C3E;
20800 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: 0x8C7F;
20801 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 0x8C80;
20802 readonly TRANSFORM_FEEDBACK_VARYINGS: 0x8C83;
20803 readonly TRANSFORM_FEEDBACK_BUFFER_START: 0x8C84;
20804 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: 0x8C85;
20805 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 0x8C88;
20806 readonly RASTERIZER_DISCARD: 0x8C89;
20807 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 0x8C8A;
20808 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 0x8C8B;
20809 readonly INTERLEAVED_ATTRIBS: 0x8C8C;
20810 readonly SEPARATE_ATTRIBS: 0x8C8D;
20811 readonly TRANSFORM_FEEDBACK_BUFFER: 0x8C8E;
20812 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: 0x8C8F;
20813 readonly RGBA32UI: 0x8D70;
20814 readonly RGB32UI: 0x8D71;
20815 readonly RGBA16UI: 0x8D76;
20816 readonly RGB16UI: 0x8D77;
20817 readonly RGBA8UI: 0x8D7C;
20818 readonly RGB8UI: 0x8D7D;
20819 readonly RGBA32I: 0x8D82;
20820 readonly RGB32I: 0x8D83;
20821 readonly RGBA16I: 0x8D88;
20822 readonly RGB16I: 0x8D89;
20823 readonly RGBA8I: 0x8D8E;
20824 readonly RGB8I: 0x8D8F;
20825 readonly RED_INTEGER: 0x8D94;
20826 readonly RGB_INTEGER: 0x8D98;
20827 readonly RGBA_INTEGER: 0x8D99;
20828 readonly SAMPLER_2D_ARRAY: 0x8DC1;
20829 readonly SAMPLER_2D_ARRAY_SHADOW: 0x8DC4;
20830 readonly SAMPLER_CUBE_SHADOW: 0x8DC5;
20831 readonly UNSIGNED_INT_VEC2: 0x8DC6;
20832 readonly UNSIGNED_INT_VEC3: 0x8DC7;
20833 readonly UNSIGNED_INT_VEC4: 0x8DC8;
20834 readonly INT_SAMPLER_2D: 0x8DCA;
20835 readonly INT_SAMPLER_3D: 0x8DCB;
20836 readonly INT_SAMPLER_CUBE: 0x8DCC;
20837 readonly INT_SAMPLER_2D_ARRAY: 0x8DCF;
20838 readonly UNSIGNED_INT_SAMPLER_2D: 0x8DD2;
20839 readonly UNSIGNED_INT_SAMPLER_3D: 0x8DD3;
20840 readonly UNSIGNED_INT_SAMPLER_CUBE: 0x8DD4;
20841 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: 0x8DD7;
20842 readonly DEPTH_COMPONENT32F: 0x8CAC;
20843 readonly DEPTH32F_STENCIL8: 0x8CAD;
20844 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: 0x8DAD;
20845 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 0x8210;
20846 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 0x8211;
20847 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: 0x8212;
20848 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 0x8213;
20849 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 0x8214;
20850 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 0x8215;
20851 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 0x8216;
20852 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 0x8217;
20853 readonly FRAMEBUFFER_DEFAULT: 0x8218;
20854 readonly UNSIGNED_INT_24_8: 0x84FA;
20855 readonly DEPTH24_STENCIL8: 0x88F0;
20856 readonly UNSIGNED_NORMALIZED: 0x8C17;
20857 readonly DRAW_FRAMEBUFFER_BINDING: 0x8CA6;
20858 readonly READ_FRAMEBUFFER: 0x8CA8;
20859 readonly DRAW_FRAMEBUFFER: 0x8CA9;
20860 readonly READ_FRAMEBUFFER_BINDING: 0x8CAA;
20861 readonly RENDERBUFFER_SAMPLES: 0x8CAB;
20862 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 0x8CD4;
20863 readonly MAX_COLOR_ATTACHMENTS: 0x8CDF;
20864 readonly COLOR_ATTACHMENT1: 0x8CE1;
20865 readonly COLOR_ATTACHMENT2: 0x8CE2;
20866 readonly COLOR_ATTACHMENT3: 0x8CE3;
20867 readonly COLOR_ATTACHMENT4: 0x8CE4;
20868 readonly COLOR_ATTACHMENT5: 0x8CE5;
20869 readonly COLOR_ATTACHMENT6: 0x8CE6;
20870 readonly COLOR_ATTACHMENT7: 0x8CE7;
20871 readonly COLOR_ATTACHMENT8: 0x8CE8;
20872 readonly COLOR_ATTACHMENT9: 0x8CE9;
20873 readonly COLOR_ATTACHMENT10: 0x8CEA;
20874 readonly COLOR_ATTACHMENT11: 0x8CEB;
20875 readonly COLOR_ATTACHMENT12: 0x8CEC;
20876 readonly COLOR_ATTACHMENT13: 0x8CED;
20877 readonly COLOR_ATTACHMENT14: 0x8CEE;
20878 readonly COLOR_ATTACHMENT15: 0x8CEF;
20879 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 0x8D56;
20880 readonly MAX_SAMPLES: 0x8D57;
20881 readonly HALF_FLOAT: 0x140B;
20882 readonly RG: 0x8227;
20883 readonly RG_INTEGER: 0x8228;
20884 readonly R8: 0x8229;
20885 readonly RG8: 0x822B;
20886 readonly R16F: 0x822D;
20887 readonly R32F: 0x822E;
20888 readonly RG16F: 0x822F;
20889 readonly RG32F: 0x8230;
20890 readonly R8I: 0x8231;
20891 readonly R8UI: 0x8232;
20892 readonly R16I: 0x8233;
20893 readonly R16UI: 0x8234;
20894 readonly R32I: 0x8235;
20895 readonly R32UI: 0x8236;
20896 readonly RG8I: 0x8237;
20897 readonly RG8UI: 0x8238;
20898 readonly RG16I: 0x8239;
20899 readonly RG16UI: 0x823A;
20900 readonly RG32I: 0x823B;
20901 readonly RG32UI: 0x823C;
20902 readonly VERTEX_ARRAY_BINDING: 0x85B5;
20903 readonly R8_SNORM: 0x8F94;
20904 readonly RG8_SNORM: 0x8F95;
20905 readonly RGB8_SNORM: 0x8F96;
20906 readonly RGBA8_SNORM: 0x8F97;
20907 readonly SIGNED_NORMALIZED: 0x8F9C;
20908 readonly COPY_READ_BUFFER: 0x8F36;
20909 readonly COPY_WRITE_BUFFER: 0x8F37;
20910 readonly COPY_READ_BUFFER_BINDING: 0x8F36;
20911 readonly COPY_WRITE_BUFFER_BINDING: 0x8F37;
20912 readonly UNIFORM_BUFFER: 0x8A11;
20913 readonly UNIFORM_BUFFER_BINDING: 0x8A28;
20914 readonly UNIFORM_BUFFER_START: 0x8A29;
20915 readonly UNIFORM_BUFFER_SIZE: 0x8A2A;
20916 readonly MAX_VERTEX_UNIFORM_BLOCKS: 0x8A2B;
20917 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: 0x8A2D;
20918 readonly MAX_COMBINED_UNIFORM_BLOCKS: 0x8A2E;
20919 readonly MAX_UNIFORM_BUFFER_BINDINGS: 0x8A2F;
20920 readonly MAX_UNIFORM_BLOCK_SIZE: 0x8A30;
20921 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 0x8A31;
20922 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 0x8A33;
20923 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: 0x8A34;
20924 readonly ACTIVE_UNIFORM_BLOCKS: 0x8A36;
20925 readonly UNIFORM_TYPE: 0x8A37;
20926 readonly UNIFORM_SIZE: 0x8A38;
20927 readonly UNIFORM_BLOCK_INDEX: 0x8A3A;
20928 readonly UNIFORM_OFFSET: 0x8A3B;
20929 readonly UNIFORM_ARRAY_STRIDE: 0x8A3C;
20930 readonly UNIFORM_MATRIX_STRIDE: 0x8A3D;
20931 readonly UNIFORM_IS_ROW_MAJOR: 0x8A3E;
20932 readonly UNIFORM_BLOCK_BINDING: 0x8A3F;
20933 readonly UNIFORM_BLOCK_DATA_SIZE: 0x8A40;
20934 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: 0x8A42;
20935 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 0x8A43;
20936 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 0x8A44;
20937 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 0x8A46;
20938 readonly INVALID_INDEX: 0xFFFFFFFF;
20939 readonly MAX_VERTEX_OUTPUT_COMPONENTS: 0x9122;
20940 readonly MAX_FRAGMENT_INPUT_COMPONENTS: 0x9125;
20941 readonly MAX_SERVER_WAIT_TIMEOUT: 0x9111;
20942 readonly OBJECT_TYPE: 0x9112;
20943 readonly SYNC_CONDITION: 0x9113;
20944 readonly SYNC_STATUS: 0x9114;
20945 readonly SYNC_FLAGS: 0x9115;
20946 readonly SYNC_FENCE: 0x9116;
20947 readonly SYNC_GPU_COMMANDS_COMPLETE: 0x9117;
20948 readonly UNSIGNALED: 0x9118;
20949 readonly SIGNALED: 0x9119;
20950 readonly ALREADY_SIGNALED: 0x911A;
20951 readonly TIMEOUT_EXPIRED: 0x911B;
20952 readonly CONDITION_SATISFIED: 0x911C;
20953 readonly WAIT_FAILED: 0x911D;
20954 readonly SYNC_FLUSH_COMMANDS_BIT: 0x00000001;
20955 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: 0x88FE;
20956 readonly ANY_SAMPLES_PASSED: 0x8C2F;
20957 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: 0x8D6A;
20958 readonly SAMPLER_BINDING: 0x8919;
20959 readonly RGB10_A2UI: 0x906F;
20960 readonly INT_2_10_10_10_REV: 0x8D9F;
20961 readonly TRANSFORM_FEEDBACK: 0x8E22;
20962 readonly TRANSFORM_FEEDBACK_PAUSED: 0x8E23;
20963 readonly TRANSFORM_FEEDBACK_ACTIVE: 0x8E24;
20964 readonly TRANSFORM_FEEDBACK_BINDING: 0x8E25;
20965 readonly TEXTURE_IMMUTABLE_FORMAT: 0x912F;
20966 readonly MAX_ELEMENT_INDEX: 0x8D6B;
20967 readonly TEXTURE_IMMUTABLE_LEVELS: 0x82DF;
20968 readonly TIMEOUT_IGNORED: -1;
20969 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 0x9247;
20970 readonly DEPTH_BUFFER_BIT: 0x00000100;
20971 readonly STENCIL_BUFFER_BIT: 0x00000400;
20972 readonly COLOR_BUFFER_BIT: 0x00004000;
20973 readonly POINTS: 0x0000;
20974 readonly LINES: 0x0001;
20975 readonly LINE_LOOP: 0x0002;
20976 readonly LINE_STRIP: 0x0003;
20977 readonly TRIANGLES: 0x0004;
20978 readonly TRIANGLE_STRIP: 0x0005;
20979 readonly TRIANGLE_FAN: 0x0006;
20982 readonly SRC_COLOR: 0x0300;
20983 readonly ONE_MINUS_SRC_COLOR: 0x0301;
20984 readonly SRC_ALPHA: 0x0302;
20985 readonly ONE_MINUS_SRC_ALPHA: 0x0303;
20986 readonly DST_ALPHA: 0x0304;
20987 readonly ONE_MINUS_DST_ALPHA: 0x0305;
20988 readonly DST_COLOR: 0x0306;
20989 readonly ONE_MINUS_DST_COLOR: 0x0307;
20990 readonly SRC_ALPHA_SATURATE: 0x0308;
20991 readonly FUNC_ADD: 0x8006;
20992 readonly BLEND_EQUATION: 0x8009;
20993 readonly BLEND_EQUATION_RGB: 0x8009;
20994 readonly BLEND_EQUATION_ALPHA: 0x883D;
20995 readonly FUNC_SUBTRACT: 0x800A;
20996 readonly FUNC_REVERSE_SUBTRACT: 0x800B;
20997 readonly BLEND_DST_RGB: 0x80C8;
20998 readonly BLEND_SRC_RGB: 0x80C9;
20999 readonly BLEND_DST_ALPHA: 0x80CA;
21000 readonly BLEND_SRC_ALPHA: 0x80CB;
21001 readonly CONSTANT_COLOR: 0x8001;
21002 readonly ONE_MINUS_CONSTANT_COLOR: 0x8002;
21003 readonly CONSTANT_ALPHA: 0x8003;
21004 readonly ONE_MINUS_CONSTANT_ALPHA: 0x8004;
21005 readonly BLEND_COLOR: 0x8005;
21006 readonly ARRAY_BUFFER: 0x8892;
21007 readonly ELEMENT_ARRAY_BUFFER: 0x8893;
21008 readonly ARRAY_BUFFER_BINDING: 0x8894;
21009 readonly ELEMENT_ARRAY_BUFFER_BINDING: 0x8895;
21010 readonly STREAM_DRAW: 0x88E0;
21011 readonly STATIC_DRAW: 0x88E4;
21012 readonly DYNAMIC_DRAW: 0x88E8;
21013 readonly BUFFER_SIZE: 0x8764;
21014 readonly BUFFER_USAGE: 0x8765;
21015 readonly CURRENT_VERTEX_ATTRIB: 0x8626;
21016 readonly FRONT: 0x0404;
21017 readonly BACK: 0x0405;
21018 readonly FRONT_AND_BACK: 0x0408;
21019 readonly CULL_FACE: 0x0B44;
21020 readonly BLEND: 0x0BE2;
21021 readonly DITHER: 0x0BD0;
21022 readonly STENCIL_TEST: 0x0B90;
21023 readonly DEPTH_TEST: 0x0B71;
21024 readonly SCISSOR_TEST: 0x0C11;
21025 readonly POLYGON_OFFSET_FILL: 0x8037;
21026 readonly SAMPLE_ALPHA_TO_COVERAGE: 0x809E;
21027 readonly SAMPLE_COVERAGE: 0x80A0;
21028 readonly NO_ERROR: 0;
21029 readonly INVALID_ENUM: 0x0500;
21030 readonly INVALID_VALUE: 0x0501;
21031 readonly INVALID_OPERATION: 0x0502;
21032 readonly OUT_OF_MEMORY: 0x0505;
21033 readonly CW: 0x0900;
21034 readonly CCW: 0x0901;
21035 readonly LINE_WIDTH: 0x0B21;
21036 readonly ALIASED_POINT_SIZE_RANGE: 0x846D;
21037 readonly ALIASED_LINE_WIDTH_RANGE: 0x846E;
21038 readonly CULL_FACE_MODE: 0x0B45;
21039 readonly FRONT_FACE: 0x0B46;
21040 readonly DEPTH_RANGE: 0x0B70;
21041 readonly DEPTH_WRITEMASK: 0x0B72;
21042 readonly DEPTH_CLEAR_VALUE: 0x0B73;
21043 readonly DEPTH_FUNC: 0x0B74;
21044 readonly STENCIL_CLEAR_VALUE: 0x0B91;
21045 readonly STENCIL_FUNC: 0x0B92;
21046 readonly STENCIL_FAIL: 0x0B94;
21047 readonly STENCIL_PASS_DEPTH_FAIL: 0x0B95;
21048 readonly STENCIL_PASS_DEPTH_PASS: 0x0B96;
21049 readonly STENCIL_REF: 0x0B97;
21050 readonly STENCIL_VALUE_MASK: 0x0B93;
21051 readonly STENCIL_WRITEMASK: 0x0B98;
21052 readonly STENCIL_BACK_FUNC: 0x8800;
21053 readonly STENCIL_BACK_FAIL: 0x8801;
21054 readonly STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802;
21055 readonly STENCIL_BACK_PASS_DEPTH_PASS: 0x8803;
21056 readonly STENCIL_BACK_REF: 0x8CA3;
21057 readonly STENCIL_BACK_VALUE_MASK: 0x8CA4;
21058 readonly STENCIL_BACK_WRITEMASK: 0x8CA5;
21059 readonly VIEWPORT: 0x0BA2;
21060 readonly SCISSOR_BOX: 0x0C10;
21061 readonly COLOR_CLEAR_VALUE: 0x0C22;
21062 readonly COLOR_WRITEMASK: 0x0C23;
21063 readonly UNPACK_ALIGNMENT: 0x0CF5;
21064 readonly PACK_ALIGNMENT: 0x0D05;
21065 readonly MAX_TEXTURE_SIZE: 0x0D33;
21066 readonly MAX_VIEWPORT_DIMS: 0x0D3A;
21067 readonly SUBPIXEL_BITS: 0x0D50;
21068 readonly RED_BITS: 0x0D52;
21069 readonly GREEN_BITS: 0x0D53;
21070 readonly BLUE_BITS: 0x0D54;
21071 readonly ALPHA_BITS: 0x0D55;
21072 readonly DEPTH_BITS: 0x0D56;
21073 readonly STENCIL_BITS: 0x0D57;
21074 readonly POLYGON_OFFSET_UNITS: 0x2A00;
21075 readonly POLYGON_OFFSET_FACTOR: 0x8038;
21076 readonly TEXTURE_BINDING_2D: 0x8069;
21077 readonly SAMPLE_BUFFERS: 0x80A8;
21078 readonly SAMPLES: 0x80A9;
21079 readonly SAMPLE_COVERAGE_VALUE: 0x80AA;
21080 readonly SAMPLE_COVERAGE_INVERT: 0x80AB;
21081 readonly COMPRESSED_TEXTURE_FORMATS: 0x86A3;
21082 readonly DONT_CARE: 0x1100;
21083 readonly FASTEST: 0x1101;
21084 readonly NICEST: 0x1102;
21085 readonly GENERATE_MIPMAP_HINT: 0x8192;
21086 readonly BYTE: 0x1400;
21087 readonly UNSIGNED_BYTE: 0x1401;
21088 readonly SHORT: 0x1402;
21089 readonly UNSIGNED_SHORT: 0x1403;
21090 readonly INT: 0x1404;
21091 readonly UNSIGNED_INT: 0x1405;
21092 readonly FLOAT: 0x1406;
21093 readonly DEPTH_COMPONENT: 0x1902;
21094 readonly ALPHA: 0x1906;
21095 readonly RGB: 0x1907;
21096 readonly RGBA: 0x1908;
21097 readonly LUMINANCE: 0x1909;
21098 readonly LUMINANCE_ALPHA: 0x190A;
21099 readonly UNSIGNED_SHORT_4_4_4_4: 0x8033;
21100 readonly UNSIGNED_SHORT_5_5_5_1: 0x8034;
21101 readonly UNSIGNED_SHORT_5_6_5: 0x8363;
21102 readonly FRAGMENT_SHADER: 0x8B30;
21103 readonly VERTEX_SHADER: 0x8B31;
21104 readonly MAX_VERTEX_ATTRIBS: 0x8869;
21105 readonly MAX_VERTEX_UNIFORM_VECTORS: 0x8DFB;
21106 readonly MAX_VARYING_VECTORS: 0x8DFC;
21107 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8B4D;
21108 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8B4C;
21109 readonly MAX_TEXTURE_IMAGE_UNITS: 0x8872;
21110 readonly MAX_FRAGMENT_UNIFORM_VECTORS: 0x8DFD;
21111 readonly SHADER_TYPE: 0x8B4F;
21112 readonly DELETE_STATUS: 0x8B80;
21113 readonly LINK_STATUS: 0x8B82;
21114 readonly VALIDATE_STATUS: 0x8B83;
21115 readonly ATTACHED_SHADERS: 0x8B85;
21116 readonly ACTIVE_UNIFORMS: 0x8B86;
21117 readonly ACTIVE_ATTRIBUTES: 0x8B89;
21118 readonly SHADING_LANGUAGE_VERSION: 0x8B8C;
21119 readonly CURRENT_PROGRAM: 0x8B8D;
21120 readonly NEVER: 0x0200;
21121 readonly LESS: 0x0201;
21122 readonly EQUAL: 0x0202;
21123 readonly LEQUAL: 0x0203;
21124 readonly GREATER: 0x0204;
21125 readonly NOTEQUAL: 0x0205;
21126 readonly GEQUAL: 0x0206;
21127 readonly ALWAYS: 0x0207;
21128 readonly KEEP: 0x1E00;
21129 readonly REPLACE: 0x1E01;
21130 readonly INCR: 0x1E02;
21131 readonly DECR: 0x1E03;
21132 readonly INVERT: 0x150A;
21133 readonly INCR_WRAP: 0x8507;
21134 readonly DECR_WRAP: 0x8508;
21135 readonly VENDOR: 0x1F00;
21136 readonly RENDERER: 0x1F01;
21137 readonly VERSION: 0x1F02;
21138 readonly NEAREST: 0x2600;
21139 readonly LINEAR: 0x2601;
21140 readonly NEAREST_MIPMAP_NEAREST: 0x2700;
21141 readonly LINEAR_MIPMAP_NEAREST: 0x2701;
21142 readonly NEAREST_MIPMAP_LINEAR: 0x2702;
21143 readonly LINEAR_MIPMAP_LINEAR: 0x2703;
21144 readonly TEXTURE_MAG_FILTER: 0x2800;
21145 readonly TEXTURE_MIN_FILTER: 0x2801;
21146 readonly TEXTURE_WRAP_S: 0x2802;
21147 readonly TEXTURE_WRAP_T: 0x2803;
21148 readonly TEXTURE_2D: 0x0DE1;
21149 readonly TEXTURE: 0x1702;
21150 readonly TEXTURE_CUBE_MAP: 0x8513;
21151 readonly TEXTURE_BINDING_CUBE_MAP: 0x8514;
21152 readonly TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515;
21153 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516;
21154 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517;
21155 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518;
21156 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519;
21157 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851A;
21158 readonly MAX_CUBE_MAP_TEXTURE_SIZE: 0x851C;
21159 readonly TEXTURE0: 0x84C0;
21160 readonly TEXTURE1: 0x84C1;
21161 readonly TEXTURE2: 0x84C2;
21162 readonly TEXTURE3: 0x84C3;
21163 readonly TEXTURE4: 0x84C4;
21164 readonly TEXTURE5: 0x84C5;
21165 readonly TEXTURE6: 0x84C6;
21166 readonly TEXTURE7: 0x84C7;
21167 readonly TEXTURE8: 0x84C8;
21168 readonly TEXTURE9: 0x84C9;
21169 readonly TEXTURE10: 0x84CA;
21170 readonly TEXTURE11: 0x84CB;
21171 readonly TEXTURE12: 0x84CC;
21172 readonly TEXTURE13: 0x84CD;
21173 readonly TEXTURE14: 0x84CE;
21174 readonly TEXTURE15: 0x84CF;
21175 readonly TEXTURE16: 0x84D0;
21176 readonly TEXTURE17: 0x84D1;
21177 readonly TEXTURE18: 0x84D2;
21178 readonly TEXTURE19: 0x84D3;
21179 readonly TEXTURE20: 0x84D4;
21180 readonly TEXTURE21: 0x84D5;
21181 readonly TEXTURE22: 0x84D6;
21182 readonly TEXTURE23: 0x84D7;
21183 readonly TEXTURE24: 0x84D8;
21184 readonly TEXTURE25: 0x84D9;
21185 readonly TEXTURE26: 0x84DA;
21186 readonly TEXTURE27: 0x84DB;
21187 readonly TEXTURE28: 0x84DC;
21188 readonly TEXTURE29: 0x84DD;
21189 readonly TEXTURE30: 0x84DE;
21190 readonly TEXTURE31: 0x84DF;
21191 readonly ACTIVE_TEXTURE: 0x84E0;
21192 readonly REPEAT: 0x2901;
21193 readonly CLAMP_TO_EDGE: 0x812F;
21194 readonly MIRRORED_REPEAT: 0x8370;
21195 readonly FLOAT_VEC2: 0x8B50;
21196 readonly FLOAT_VEC3: 0x8B51;
21197 readonly FLOAT_VEC4: 0x8B52;
21198 readonly INT_VEC2: 0x8B53;
21199 readonly INT_VEC3: 0x8B54;
21200 readonly INT_VEC4: 0x8B55;
21201 readonly BOOL: 0x8B56;
21202 readonly BOOL_VEC2: 0x8B57;
21203 readonly BOOL_VEC3: 0x8B58;
21204 readonly BOOL_VEC4: 0x8B59;
21205 readonly FLOAT_MAT2: 0x8B5A;
21206 readonly FLOAT_MAT3: 0x8B5B;
21207 readonly FLOAT_MAT4: 0x8B5C;
21208 readonly SAMPLER_2D: 0x8B5E;
21209 readonly SAMPLER_CUBE: 0x8B60;
21210 readonly VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622;
21211 readonly VERTEX_ATTRIB_ARRAY_SIZE: 0x8623;
21212 readonly VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624;
21213 readonly VERTEX_ATTRIB_ARRAY_TYPE: 0x8625;
21214 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886A;
21215 readonly VERTEX_ATTRIB_ARRAY_POINTER: 0x8645;
21216 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889F;
21217 readonly IMPLEMENTATION_COLOR_READ_TYPE: 0x8B9A;
21218 readonly IMPLEMENTATION_COLOR_READ_FORMAT: 0x8B9B;
21219 readonly COMPILE_STATUS: 0x8B81;
21220 readonly LOW_FLOAT: 0x8DF0;
21221 readonly MEDIUM_FLOAT: 0x8DF1;
21222 readonly HIGH_FLOAT: 0x8DF2;
21223 readonly LOW_INT: 0x8DF3;
21224 readonly MEDIUM_INT: 0x8DF4;
21225 readonly HIGH_INT: 0x8DF5;
21226 readonly FRAMEBUFFER: 0x8D40;
21227 readonly RENDERBUFFER: 0x8D41;
21228 readonly RGBA4: 0x8056;
21229 readonly RGB5_A1: 0x8057;
21230 readonly RGB565: 0x8D62;
21231 readonly DEPTH_COMPONENT16: 0x81A5;
21232 readonly STENCIL_INDEX8: 0x8D48;
21233 readonly DEPTH_STENCIL: 0x84F9;
21234 readonly RENDERBUFFER_WIDTH: 0x8D42;
21235 readonly RENDERBUFFER_HEIGHT: 0x8D43;
21236 readonly RENDERBUFFER_INTERNAL_FORMAT: 0x8D44;
21237 readonly RENDERBUFFER_RED_SIZE: 0x8D50;
21238 readonly RENDERBUFFER_GREEN_SIZE: 0x8D51;
21239 readonly RENDERBUFFER_BLUE_SIZE: 0x8D52;
21240 readonly RENDERBUFFER_ALPHA_SIZE: 0x8D53;
21241 readonly RENDERBUFFER_DEPTH_SIZE: 0x8D54;
21242 readonly RENDERBUFFER_STENCIL_SIZE: 0x8D55;
21243 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8CD0;
21244 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8CD1;
21245 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8CD2;
21246 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8CD3;
21247 readonly COLOR_ATTACHMENT0: 0x8CE0;
21248 readonly DEPTH_ATTACHMENT: 0x8D00;
21249 readonly STENCIL_ATTACHMENT: 0x8D20;
21250 readonly DEPTH_STENCIL_ATTACHMENT: 0x821A;
21252 readonly FRAMEBUFFER_COMPLETE: 0x8CD5;
21253 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8CD6;
21254 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8CD7;
21255 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8CD9;
21256 readonly FRAMEBUFFER_UNSUPPORTED: 0x8CDD;
21257 readonly FRAMEBUFFER_BINDING: 0x8CA6;
21258 readonly RENDERBUFFER_BINDING: 0x8CA7;
21259 readonly MAX_RENDERBUFFER_SIZE: 0x84E8;
21260 readonly INVALID_FRAMEBUFFER_OPERATION: 0x0506;
21261 readonly UNPACK_FLIP_Y_WEBGL: 0x9240;
21262 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241;
21263 readonly CONTEXT_LOST_WEBGL: 0x9242;
21264 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243;
21265 readonly BROWSER_DEFAULT_WEBGL: 0x9244;
21266 isInstance: IsInstance<WebGL2RenderingContext>;
21269 interface WebGL2RenderingContextBase {
21270 beginQuery(target: GLenum, query: WebGLQuery): void;
21271 beginTransformFeedback(primitiveMode: GLenum): void;
21272 bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null): void;
21273 bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr): void;
21274 bindSampler(unit: GLuint, sampler: WebGLSampler | null): void;
21275 bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null): void;
21276 bindVertexArray(array: WebGLVertexArrayObject | null): void;
21277 blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
21278 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
21279 bufferData(target: GLenum, srcData: ArrayBuffer | null, usage: GLenum): void;
21280 bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum): void;
21281 bufferData(target: GLenum, srcData: ArrayBufferView, usage: GLenum, srcOffset: GLuint, length?: GLuint): void;
21282 bufferSubData(target: GLenum, offset: GLintptr, srcData: ArrayBuffer): void;
21283 bufferSubData(target: GLenum, offset: GLintptr, srcData: ArrayBufferView): void;
21284 bufferSubData(target: GLenum, dstByteOffset: GLintptr, srcData: ArrayBufferView, srcOffset: GLuint, length?: GLuint): void;
21285 clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint): void;
21286 clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint): void;
21287 clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint): void;
21288 clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint): void;
21289 clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum;
21290 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
21291 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
21292 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr): void;
21293 compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
21294 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
21295 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
21296 compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr): void;
21297 compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint): void;
21298 copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr): void;
21299 copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
21300 createQuery(): WebGLQuery | null;
21301 createSampler(): WebGLSampler | null;
21302 createTransformFeedback(): WebGLTransformFeedback | null;
21303 createVertexArray(): WebGLVertexArrayObject | null;
21304 deleteQuery(query: WebGLQuery | null): void;
21305 deleteSampler(sampler: WebGLSampler | null): void;
21306 deleteSync(sync: WebGLSync | null): void;
21307 deleteTransformFeedback(tf: WebGLTransformFeedback | null): void;
21308 deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
21309 drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
21310 drawBuffers(buffers: GLenum[]): void;
21311 drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
21312 drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr): void;
21313 endQuery(target: GLenum): void;
21314 endTransformFeedback(): void;
21315 fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null;
21316 framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint): void;
21317 getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null;
21318 getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any;
21319 getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any;
21320 getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstData: ArrayBufferView, dstOffset?: GLuint, length?: GLuint): void;
21321 getFragDataLocation(program: WebGLProgram, name: string): GLint;
21322 getIndexedParameter(target: GLenum, index: GLuint): any;
21323 getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any;
21324 getQuery(target: GLenum, pname: GLenum): any;
21325 getQueryParameter(query: WebGLQuery, pname: GLenum): any;
21326 getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any;
21327 getSyncParameter(sync: WebGLSync, pname: GLenum): any;
21328 getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
21329 getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint;
21330 getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null;
21331 invalidateFramebuffer(target: GLenum, attachments: GLenum[]): void;
21332 invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
21333 isQuery(query: WebGLQuery | null): GLboolean;
21334 isSampler(sampler: WebGLSampler | null): GLboolean;
21335 isSync(sync: WebGLSync | null): GLboolean;
21336 isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean;
21337 isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
21338 pauseTransformFeedback(): void;
21339 readBuffer(src: GLenum): void;
21340 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null): void;
21341 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr): void;
21342 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint): void;
21343 renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
21344 resumeTransformFeedback(): void;
21345 samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat): void;
21346 samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint): void;
21347 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
21348 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21349 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21350 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21351 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: ImageBitmap): void;
21352 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: ImageData): void;
21353 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21354 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: VideoFrame): void;
21355 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
21356 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21357 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21358 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21359 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: ImageBitmap): void;
21360 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: ImageData): void;
21361 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21362 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: VideoFrame): void;
21363 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
21364 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
21365 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21366 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21367 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21368 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: ImageBitmap): void;
21369 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: ImageData): void;
21370 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21371 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: VideoFrame): void;
21372 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView | null): void;
21373 texImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
21374 texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
21375 texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei): void;
21376 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
21377 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21378 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21379 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21380 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: ImageBitmap): void;
21381 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: ImageData): void;
21382 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21383 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: VideoFrame): void;
21384 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
21385 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21386 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21387 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21388 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: ImageBitmap): void;
21389 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: ImageData): void;
21390 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21391 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: VideoFrame): void;
21392 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint): void;
21393 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr): void;
21394 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: HTMLCanvasElement): void;
21395 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: HTMLImageElement): void;
21396 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: HTMLVideoElement): void;
21397 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: ImageBitmap): void;
21398 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: ImageData): void;
21399 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: OffscreenCanvas): void;
21400 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: VideoFrame): void;
21401 texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView | null, srcOffset?: GLuint): void;
21402 transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum): void;
21403 uniform1fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21404 uniform1iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21405 uniform1ui(location: WebGLUniformLocation | null, v0: GLuint): void;
21406 uniform1uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21407 uniform2fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21408 uniform2iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21409 uniform2ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint): void;
21410 uniform2uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21411 uniform3fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21412 uniform3iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21413 uniform3ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint): void;
21414 uniform3uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21415 uniform4fv(location: WebGLUniformLocation | null, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21416 uniform4iv(location: WebGLUniformLocation | null, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21417 uniform4ui(location: WebGLUniformLocation | null, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint): void;
21418 uniform4uiv(location: WebGLUniformLocation | null, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21419 uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint): void;
21420 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21421 uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21422 uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21423 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21424 uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21425 uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21426 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21427 uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21428 uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint): void;
21429 vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
21430 vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint): void;
21431 vertexAttribI4iv(index: GLuint, values: Int32List): void;
21432 vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint): void;
21433 vertexAttribI4uiv(index: GLuint, values: Uint32List): void;
21434 vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr): void;
21435 waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64): void;
21436 readonly READ_BUFFER: 0x0C02;
21437 readonly UNPACK_ROW_LENGTH: 0x0CF2;
21438 readonly UNPACK_SKIP_ROWS: 0x0CF3;
21439 readonly UNPACK_SKIP_PIXELS: 0x0CF4;
21440 readonly PACK_ROW_LENGTH: 0x0D02;
21441 readonly PACK_SKIP_ROWS: 0x0D03;
21442 readonly PACK_SKIP_PIXELS: 0x0D04;
21443 readonly COLOR: 0x1800;
21444 readonly DEPTH: 0x1801;
21445 readonly STENCIL: 0x1802;
21446 readonly RED: 0x1903;
21447 readonly RGB8: 0x8051;
21448 readonly RGBA8: 0x8058;
21449 readonly RGB10_A2: 0x8059;
21450 readonly TEXTURE_BINDING_3D: 0x806A;
21451 readonly UNPACK_SKIP_IMAGES: 0x806D;
21452 readonly UNPACK_IMAGE_HEIGHT: 0x806E;
21453 readonly TEXTURE_3D: 0x806F;
21454 readonly TEXTURE_WRAP_R: 0x8072;
21455 readonly MAX_3D_TEXTURE_SIZE: 0x8073;
21456 readonly UNSIGNED_INT_2_10_10_10_REV: 0x8368;
21457 readonly MAX_ELEMENTS_VERTICES: 0x80E8;
21458 readonly MAX_ELEMENTS_INDICES: 0x80E9;
21459 readonly TEXTURE_MIN_LOD: 0x813A;
21460 readonly TEXTURE_MAX_LOD: 0x813B;
21461 readonly TEXTURE_BASE_LEVEL: 0x813C;
21462 readonly TEXTURE_MAX_LEVEL: 0x813D;
21463 readonly MIN: 0x8007;
21464 readonly MAX: 0x8008;
21465 readonly DEPTH_COMPONENT24: 0x81A6;
21466 readonly MAX_TEXTURE_LOD_BIAS: 0x84FD;
21467 readonly TEXTURE_COMPARE_MODE: 0x884C;
21468 readonly TEXTURE_COMPARE_FUNC: 0x884D;
21469 readonly CURRENT_QUERY: 0x8865;
21470 readonly QUERY_RESULT: 0x8866;
21471 readonly QUERY_RESULT_AVAILABLE: 0x8867;
21472 readonly STREAM_READ: 0x88E1;
21473 readonly STREAM_COPY: 0x88E2;
21474 readonly STATIC_READ: 0x88E5;
21475 readonly STATIC_COPY: 0x88E6;
21476 readonly DYNAMIC_READ: 0x88E9;
21477 readonly DYNAMIC_COPY: 0x88EA;
21478 readonly MAX_DRAW_BUFFERS: 0x8824;
21479 readonly DRAW_BUFFER0: 0x8825;
21480 readonly DRAW_BUFFER1: 0x8826;
21481 readonly DRAW_BUFFER2: 0x8827;
21482 readonly DRAW_BUFFER3: 0x8828;
21483 readonly DRAW_BUFFER4: 0x8829;
21484 readonly DRAW_BUFFER5: 0x882A;
21485 readonly DRAW_BUFFER6: 0x882B;
21486 readonly DRAW_BUFFER7: 0x882C;
21487 readonly DRAW_BUFFER8: 0x882D;
21488 readonly DRAW_BUFFER9: 0x882E;
21489 readonly DRAW_BUFFER10: 0x882F;
21490 readonly DRAW_BUFFER11: 0x8830;
21491 readonly DRAW_BUFFER12: 0x8831;
21492 readonly DRAW_BUFFER13: 0x8832;
21493 readonly DRAW_BUFFER14: 0x8833;
21494 readonly DRAW_BUFFER15: 0x8834;
21495 readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: 0x8B49;
21496 readonly MAX_VERTEX_UNIFORM_COMPONENTS: 0x8B4A;
21497 readonly SAMPLER_3D: 0x8B5F;
21498 readonly SAMPLER_2D_SHADOW: 0x8B62;
21499 readonly FRAGMENT_SHADER_DERIVATIVE_HINT: 0x8B8B;
21500 readonly PIXEL_PACK_BUFFER: 0x88EB;
21501 readonly PIXEL_UNPACK_BUFFER: 0x88EC;
21502 readonly PIXEL_PACK_BUFFER_BINDING: 0x88ED;
21503 readonly PIXEL_UNPACK_BUFFER_BINDING: 0x88EF;
21504 readonly FLOAT_MAT2x3: 0x8B65;
21505 readonly FLOAT_MAT2x4: 0x8B66;
21506 readonly FLOAT_MAT3x2: 0x8B67;
21507 readonly FLOAT_MAT3x4: 0x8B68;
21508 readonly FLOAT_MAT4x2: 0x8B69;
21509 readonly FLOAT_MAT4x3: 0x8B6A;
21510 readonly SRGB: 0x8C40;
21511 readonly SRGB8: 0x8C41;
21512 readonly SRGB8_ALPHA8: 0x8C43;
21513 readonly COMPARE_REF_TO_TEXTURE: 0x884E;
21514 readonly RGBA32F: 0x8814;
21515 readonly RGB32F: 0x8815;
21516 readonly RGBA16F: 0x881A;
21517 readonly RGB16F: 0x881B;
21518 readonly VERTEX_ATTRIB_ARRAY_INTEGER: 0x88FD;
21519 readonly MAX_ARRAY_TEXTURE_LAYERS: 0x88FF;
21520 readonly MIN_PROGRAM_TEXEL_OFFSET: 0x8904;
21521 readonly MAX_PROGRAM_TEXEL_OFFSET: 0x8905;
21522 readonly MAX_VARYING_COMPONENTS: 0x8B4B;
21523 readonly TEXTURE_2D_ARRAY: 0x8C1A;
21524 readonly TEXTURE_BINDING_2D_ARRAY: 0x8C1D;
21525 readonly R11F_G11F_B10F: 0x8C3A;
21526 readonly UNSIGNED_INT_10F_11F_11F_REV: 0x8C3B;
21527 readonly RGB9_E5: 0x8C3D;
21528 readonly UNSIGNED_INT_5_9_9_9_REV: 0x8C3E;
21529 readonly TRANSFORM_FEEDBACK_BUFFER_MODE: 0x8C7F;
21530 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: 0x8C80;
21531 readonly TRANSFORM_FEEDBACK_VARYINGS: 0x8C83;
21532 readonly TRANSFORM_FEEDBACK_BUFFER_START: 0x8C84;
21533 readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: 0x8C85;
21534 readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 0x8C88;
21535 readonly RASTERIZER_DISCARD: 0x8C89;
21536 readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: 0x8C8A;
21537 readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: 0x8C8B;
21538 readonly INTERLEAVED_ATTRIBS: 0x8C8C;
21539 readonly SEPARATE_ATTRIBS: 0x8C8D;
21540 readonly TRANSFORM_FEEDBACK_BUFFER: 0x8C8E;
21541 readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: 0x8C8F;
21542 readonly RGBA32UI: 0x8D70;
21543 readonly RGB32UI: 0x8D71;
21544 readonly RGBA16UI: 0x8D76;
21545 readonly RGB16UI: 0x8D77;
21546 readonly RGBA8UI: 0x8D7C;
21547 readonly RGB8UI: 0x8D7D;
21548 readonly RGBA32I: 0x8D82;
21549 readonly RGB32I: 0x8D83;
21550 readonly RGBA16I: 0x8D88;
21551 readonly RGB16I: 0x8D89;
21552 readonly RGBA8I: 0x8D8E;
21553 readonly RGB8I: 0x8D8F;
21554 readonly RED_INTEGER: 0x8D94;
21555 readonly RGB_INTEGER: 0x8D98;
21556 readonly RGBA_INTEGER: 0x8D99;
21557 readonly SAMPLER_2D_ARRAY: 0x8DC1;
21558 readonly SAMPLER_2D_ARRAY_SHADOW: 0x8DC4;
21559 readonly SAMPLER_CUBE_SHADOW: 0x8DC5;
21560 readonly UNSIGNED_INT_VEC2: 0x8DC6;
21561 readonly UNSIGNED_INT_VEC3: 0x8DC7;
21562 readonly UNSIGNED_INT_VEC4: 0x8DC8;
21563 readonly INT_SAMPLER_2D: 0x8DCA;
21564 readonly INT_SAMPLER_3D: 0x8DCB;
21565 readonly INT_SAMPLER_CUBE: 0x8DCC;
21566 readonly INT_SAMPLER_2D_ARRAY: 0x8DCF;
21567 readonly UNSIGNED_INT_SAMPLER_2D: 0x8DD2;
21568 readonly UNSIGNED_INT_SAMPLER_3D: 0x8DD3;
21569 readonly UNSIGNED_INT_SAMPLER_CUBE: 0x8DD4;
21570 readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: 0x8DD7;
21571 readonly DEPTH_COMPONENT32F: 0x8CAC;
21572 readonly DEPTH32F_STENCIL8: 0x8CAD;
21573 readonly FLOAT_32_UNSIGNED_INT_24_8_REV: 0x8DAD;
21574 readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: 0x8210;
21575 readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: 0x8211;
21576 readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: 0x8212;
21577 readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 0x8213;
21578 readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 0x8214;
21579 readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 0x8215;
21580 readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 0x8216;
21581 readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 0x8217;
21582 readonly FRAMEBUFFER_DEFAULT: 0x8218;
21583 readonly UNSIGNED_INT_24_8: 0x84FA;
21584 readonly DEPTH24_STENCIL8: 0x88F0;
21585 readonly UNSIGNED_NORMALIZED: 0x8C17;
21586 readonly DRAW_FRAMEBUFFER_BINDING: 0x8CA6;
21587 readonly READ_FRAMEBUFFER: 0x8CA8;
21588 readonly DRAW_FRAMEBUFFER: 0x8CA9;
21589 readonly READ_FRAMEBUFFER_BINDING: 0x8CAA;
21590 readonly RENDERBUFFER_SAMPLES: 0x8CAB;
21591 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: 0x8CD4;
21592 readonly MAX_COLOR_ATTACHMENTS: 0x8CDF;
21593 readonly COLOR_ATTACHMENT1: 0x8CE1;
21594 readonly COLOR_ATTACHMENT2: 0x8CE2;
21595 readonly COLOR_ATTACHMENT3: 0x8CE3;
21596 readonly COLOR_ATTACHMENT4: 0x8CE4;
21597 readonly COLOR_ATTACHMENT5: 0x8CE5;
21598 readonly COLOR_ATTACHMENT6: 0x8CE6;
21599 readonly COLOR_ATTACHMENT7: 0x8CE7;
21600 readonly COLOR_ATTACHMENT8: 0x8CE8;
21601 readonly COLOR_ATTACHMENT9: 0x8CE9;
21602 readonly COLOR_ATTACHMENT10: 0x8CEA;
21603 readonly COLOR_ATTACHMENT11: 0x8CEB;
21604 readonly COLOR_ATTACHMENT12: 0x8CEC;
21605 readonly COLOR_ATTACHMENT13: 0x8CED;
21606 readonly COLOR_ATTACHMENT14: 0x8CEE;
21607 readonly COLOR_ATTACHMENT15: 0x8CEF;
21608 readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: 0x8D56;
21609 readonly MAX_SAMPLES: 0x8D57;
21610 readonly HALF_FLOAT: 0x140B;
21611 readonly RG: 0x8227;
21612 readonly RG_INTEGER: 0x8228;
21613 readonly R8: 0x8229;
21614 readonly RG8: 0x822B;
21615 readonly R16F: 0x822D;
21616 readonly R32F: 0x822E;
21617 readonly RG16F: 0x822F;
21618 readonly RG32F: 0x8230;
21619 readonly R8I: 0x8231;
21620 readonly R8UI: 0x8232;
21621 readonly R16I: 0x8233;
21622 readonly R16UI: 0x8234;
21623 readonly R32I: 0x8235;
21624 readonly R32UI: 0x8236;
21625 readonly RG8I: 0x8237;
21626 readonly RG8UI: 0x8238;
21627 readonly RG16I: 0x8239;
21628 readonly RG16UI: 0x823A;
21629 readonly RG32I: 0x823B;
21630 readonly RG32UI: 0x823C;
21631 readonly VERTEX_ARRAY_BINDING: 0x85B5;
21632 readonly R8_SNORM: 0x8F94;
21633 readonly RG8_SNORM: 0x8F95;
21634 readonly RGB8_SNORM: 0x8F96;
21635 readonly RGBA8_SNORM: 0x8F97;
21636 readonly SIGNED_NORMALIZED: 0x8F9C;
21637 readonly COPY_READ_BUFFER: 0x8F36;
21638 readonly COPY_WRITE_BUFFER: 0x8F37;
21639 readonly COPY_READ_BUFFER_BINDING: 0x8F36;
21640 readonly COPY_WRITE_BUFFER_BINDING: 0x8F37;
21641 readonly UNIFORM_BUFFER: 0x8A11;
21642 readonly UNIFORM_BUFFER_BINDING: 0x8A28;
21643 readonly UNIFORM_BUFFER_START: 0x8A29;
21644 readonly UNIFORM_BUFFER_SIZE: 0x8A2A;
21645 readonly MAX_VERTEX_UNIFORM_BLOCKS: 0x8A2B;
21646 readonly MAX_FRAGMENT_UNIFORM_BLOCKS: 0x8A2D;
21647 readonly MAX_COMBINED_UNIFORM_BLOCKS: 0x8A2E;
21648 readonly MAX_UNIFORM_BUFFER_BINDINGS: 0x8A2F;
21649 readonly MAX_UNIFORM_BLOCK_SIZE: 0x8A30;
21650 readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: 0x8A31;
21651 readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: 0x8A33;
21652 readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: 0x8A34;
21653 readonly ACTIVE_UNIFORM_BLOCKS: 0x8A36;
21654 readonly UNIFORM_TYPE: 0x8A37;
21655 readonly UNIFORM_SIZE: 0x8A38;
21656 readonly UNIFORM_BLOCK_INDEX: 0x8A3A;
21657 readonly UNIFORM_OFFSET: 0x8A3B;
21658 readonly UNIFORM_ARRAY_STRIDE: 0x8A3C;
21659 readonly UNIFORM_MATRIX_STRIDE: 0x8A3D;
21660 readonly UNIFORM_IS_ROW_MAJOR: 0x8A3E;
21661 readonly UNIFORM_BLOCK_BINDING: 0x8A3F;
21662 readonly UNIFORM_BLOCK_DATA_SIZE: 0x8A40;
21663 readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: 0x8A42;
21664 readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: 0x8A43;
21665 readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: 0x8A44;
21666 readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: 0x8A46;
21667 readonly INVALID_INDEX: 0xFFFFFFFF;
21668 readonly MAX_VERTEX_OUTPUT_COMPONENTS: 0x9122;
21669 readonly MAX_FRAGMENT_INPUT_COMPONENTS: 0x9125;
21670 readonly MAX_SERVER_WAIT_TIMEOUT: 0x9111;
21671 readonly OBJECT_TYPE: 0x9112;
21672 readonly SYNC_CONDITION: 0x9113;
21673 readonly SYNC_STATUS: 0x9114;
21674 readonly SYNC_FLAGS: 0x9115;
21675 readonly SYNC_FENCE: 0x9116;
21676 readonly SYNC_GPU_COMMANDS_COMPLETE: 0x9117;
21677 readonly UNSIGNALED: 0x9118;
21678 readonly SIGNALED: 0x9119;
21679 readonly ALREADY_SIGNALED: 0x911A;
21680 readonly TIMEOUT_EXPIRED: 0x911B;
21681 readonly CONDITION_SATISFIED: 0x911C;
21682 readonly WAIT_FAILED: 0x911D;
21683 readonly SYNC_FLUSH_COMMANDS_BIT: 0x00000001;
21684 readonly VERTEX_ATTRIB_ARRAY_DIVISOR: 0x88FE;
21685 readonly ANY_SAMPLES_PASSED: 0x8C2F;
21686 readonly ANY_SAMPLES_PASSED_CONSERVATIVE: 0x8D6A;
21687 readonly SAMPLER_BINDING: 0x8919;
21688 readonly RGB10_A2UI: 0x906F;
21689 readonly INT_2_10_10_10_REV: 0x8D9F;
21690 readonly TRANSFORM_FEEDBACK: 0x8E22;
21691 readonly TRANSFORM_FEEDBACK_PAUSED: 0x8E23;
21692 readonly TRANSFORM_FEEDBACK_ACTIVE: 0x8E24;
21693 readonly TRANSFORM_FEEDBACK_BINDING: 0x8E25;
21694 readonly TEXTURE_IMMUTABLE_FORMAT: 0x912F;
21695 readonly MAX_ELEMENT_INDEX: 0x8D6B;
21696 readonly TEXTURE_IMMUTABLE_LEVELS: 0x82DF;
21697 readonly TIMEOUT_IGNORED: -1;
21698 readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 0x9247;
21701 interface WebGLActiveInfo {
21702 readonly name: string;
21703 readonly size: GLint;
21704 readonly type: GLenum;
21707 declare var WebGLActiveInfo: {
21708 prototype: WebGLActiveInfo;
21709 new(): WebGLActiveInfo;
21710 isInstance: IsInstance<WebGLActiveInfo>;
21713 interface WebGLBuffer {
21716 declare var WebGLBuffer: {
21717 prototype: WebGLBuffer;
21718 new(): WebGLBuffer;
21719 isInstance: IsInstance<WebGLBuffer>;
21722 interface WebGLContextEvent extends Event {
21723 readonly statusMessage: string;
21726 declare var WebGLContextEvent: {
21727 prototype: WebGLContextEvent;
21728 new(type: string, eventInit?: WebGLContextEventInit): WebGLContextEvent;
21729 isInstance: IsInstance<WebGLContextEvent>;
21732 interface WebGLFramebuffer {
21735 declare var WebGLFramebuffer: {
21736 prototype: WebGLFramebuffer;
21737 new(): WebGLFramebuffer;
21738 isInstance: IsInstance<WebGLFramebuffer>;
21741 interface WebGLProgram {
21744 declare var WebGLProgram: {
21745 prototype: WebGLProgram;
21746 new(): WebGLProgram;
21747 isInstance: IsInstance<WebGLProgram>;
21750 interface WebGLQuery {
21753 declare var WebGLQuery: {
21754 prototype: WebGLQuery;
21756 isInstance: IsInstance<WebGLQuery>;
21759 interface WebGLRenderbuffer {
21762 declare var WebGLRenderbuffer: {
21763 prototype: WebGLRenderbuffer;
21764 new(): WebGLRenderbuffer;
21765 isInstance: IsInstance<WebGLRenderbuffer>;
21768 interface WebGLRenderingContext extends WebGLRenderingContextBase {
21769 bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void;
21770 bufferData(target: GLenum, data: ArrayBuffer | null, usage: GLenum): void;
21771 bufferData(target: GLenum, data: ArrayBufferView, usage: GLenum): void;
21772 bufferSubData(target: GLenum, offset: GLintptr, data: ArrayBuffer): void;
21773 bufferSubData(target: GLenum, offset: GLintptr, data: ArrayBufferView): void;
21774 compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: ArrayBufferView): void;
21775 compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: ArrayBufferView): void;
21776 readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
21777 texImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
21778 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, pixels: ImageBitmap): void;
21779 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, pixels: ImageData): void;
21780 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, image: HTMLImageElement): void;
21781 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, canvas: HTMLCanvasElement): void;
21782 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, video: HTMLVideoElement): void;
21783 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, canvas: OffscreenCanvas): void;
21784 texImage2D(target: GLenum, level: GLint, internalformat: GLint, format: GLenum, type: GLenum, videoFrame: VideoFrame): void;
21785 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
21786 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, pixels: ImageBitmap): void;
21787 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, pixels: ImageData): void;
21788 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, image: HTMLImageElement): void;
21789 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, canvas: HTMLCanvasElement): void;
21790 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, video: HTMLVideoElement): void;
21791 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, canvas: OffscreenCanvas): void;
21792 texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, videoFrame: VideoFrame): void;
21793 uniform1fv(location: WebGLUniformLocation | null, data: Float32List): void;
21794 uniform1iv(location: WebGLUniformLocation | null, data: Int32List): void;
21795 uniform2fv(location: WebGLUniformLocation | null, data: Float32List): void;
21796 uniform2iv(location: WebGLUniformLocation | null, data: Int32List): void;
21797 uniform3fv(location: WebGLUniformLocation | null, data: Float32List): void;
21798 uniform3iv(location: WebGLUniformLocation | null, data: Int32List): void;
21799 uniform4fv(location: WebGLUniformLocation | null, data: Float32List): void;
21800 uniform4iv(location: WebGLUniformLocation | null, data: Int32List): void;
21801 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List): void;
21802 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List): void;
21803 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List): void;
21806 declare var WebGLRenderingContext: {
21807 prototype: WebGLRenderingContext;
21808 new(): WebGLRenderingContext;
21809 readonly DEPTH_BUFFER_BIT: 0x00000100;
21810 readonly STENCIL_BUFFER_BIT: 0x00000400;
21811 readonly COLOR_BUFFER_BIT: 0x00004000;
21812 readonly POINTS: 0x0000;
21813 readonly LINES: 0x0001;
21814 readonly LINE_LOOP: 0x0002;
21815 readonly LINE_STRIP: 0x0003;
21816 readonly TRIANGLES: 0x0004;
21817 readonly TRIANGLE_STRIP: 0x0005;
21818 readonly TRIANGLE_FAN: 0x0006;
21821 readonly SRC_COLOR: 0x0300;
21822 readonly ONE_MINUS_SRC_COLOR: 0x0301;
21823 readonly SRC_ALPHA: 0x0302;
21824 readonly ONE_MINUS_SRC_ALPHA: 0x0303;
21825 readonly DST_ALPHA: 0x0304;
21826 readonly ONE_MINUS_DST_ALPHA: 0x0305;
21827 readonly DST_COLOR: 0x0306;
21828 readonly ONE_MINUS_DST_COLOR: 0x0307;
21829 readonly SRC_ALPHA_SATURATE: 0x0308;
21830 readonly FUNC_ADD: 0x8006;
21831 readonly BLEND_EQUATION: 0x8009;
21832 readonly BLEND_EQUATION_RGB: 0x8009;
21833 readonly BLEND_EQUATION_ALPHA: 0x883D;
21834 readonly FUNC_SUBTRACT: 0x800A;
21835 readonly FUNC_REVERSE_SUBTRACT: 0x800B;
21836 readonly BLEND_DST_RGB: 0x80C8;
21837 readonly BLEND_SRC_RGB: 0x80C9;
21838 readonly BLEND_DST_ALPHA: 0x80CA;
21839 readonly BLEND_SRC_ALPHA: 0x80CB;
21840 readonly CONSTANT_COLOR: 0x8001;
21841 readonly ONE_MINUS_CONSTANT_COLOR: 0x8002;
21842 readonly CONSTANT_ALPHA: 0x8003;
21843 readonly ONE_MINUS_CONSTANT_ALPHA: 0x8004;
21844 readonly BLEND_COLOR: 0x8005;
21845 readonly ARRAY_BUFFER: 0x8892;
21846 readonly ELEMENT_ARRAY_BUFFER: 0x8893;
21847 readonly ARRAY_BUFFER_BINDING: 0x8894;
21848 readonly ELEMENT_ARRAY_BUFFER_BINDING: 0x8895;
21849 readonly STREAM_DRAW: 0x88E0;
21850 readonly STATIC_DRAW: 0x88E4;
21851 readonly DYNAMIC_DRAW: 0x88E8;
21852 readonly BUFFER_SIZE: 0x8764;
21853 readonly BUFFER_USAGE: 0x8765;
21854 readonly CURRENT_VERTEX_ATTRIB: 0x8626;
21855 readonly FRONT: 0x0404;
21856 readonly BACK: 0x0405;
21857 readonly FRONT_AND_BACK: 0x0408;
21858 readonly CULL_FACE: 0x0B44;
21859 readonly BLEND: 0x0BE2;
21860 readonly DITHER: 0x0BD0;
21861 readonly STENCIL_TEST: 0x0B90;
21862 readonly DEPTH_TEST: 0x0B71;
21863 readonly SCISSOR_TEST: 0x0C11;
21864 readonly POLYGON_OFFSET_FILL: 0x8037;
21865 readonly SAMPLE_ALPHA_TO_COVERAGE: 0x809E;
21866 readonly SAMPLE_COVERAGE: 0x80A0;
21867 readonly NO_ERROR: 0;
21868 readonly INVALID_ENUM: 0x0500;
21869 readonly INVALID_VALUE: 0x0501;
21870 readonly INVALID_OPERATION: 0x0502;
21871 readonly OUT_OF_MEMORY: 0x0505;
21872 readonly CW: 0x0900;
21873 readonly CCW: 0x0901;
21874 readonly LINE_WIDTH: 0x0B21;
21875 readonly ALIASED_POINT_SIZE_RANGE: 0x846D;
21876 readonly ALIASED_LINE_WIDTH_RANGE: 0x846E;
21877 readonly CULL_FACE_MODE: 0x0B45;
21878 readonly FRONT_FACE: 0x0B46;
21879 readonly DEPTH_RANGE: 0x0B70;
21880 readonly DEPTH_WRITEMASK: 0x0B72;
21881 readonly DEPTH_CLEAR_VALUE: 0x0B73;
21882 readonly DEPTH_FUNC: 0x0B74;
21883 readonly STENCIL_CLEAR_VALUE: 0x0B91;
21884 readonly STENCIL_FUNC: 0x0B92;
21885 readonly STENCIL_FAIL: 0x0B94;
21886 readonly STENCIL_PASS_DEPTH_FAIL: 0x0B95;
21887 readonly STENCIL_PASS_DEPTH_PASS: 0x0B96;
21888 readonly STENCIL_REF: 0x0B97;
21889 readonly STENCIL_VALUE_MASK: 0x0B93;
21890 readonly STENCIL_WRITEMASK: 0x0B98;
21891 readonly STENCIL_BACK_FUNC: 0x8800;
21892 readonly STENCIL_BACK_FAIL: 0x8801;
21893 readonly STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802;
21894 readonly STENCIL_BACK_PASS_DEPTH_PASS: 0x8803;
21895 readonly STENCIL_BACK_REF: 0x8CA3;
21896 readonly STENCIL_BACK_VALUE_MASK: 0x8CA4;
21897 readonly STENCIL_BACK_WRITEMASK: 0x8CA5;
21898 readonly VIEWPORT: 0x0BA2;
21899 readonly SCISSOR_BOX: 0x0C10;
21900 readonly COLOR_CLEAR_VALUE: 0x0C22;
21901 readonly COLOR_WRITEMASK: 0x0C23;
21902 readonly UNPACK_ALIGNMENT: 0x0CF5;
21903 readonly PACK_ALIGNMENT: 0x0D05;
21904 readonly MAX_TEXTURE_SIZE: 0x0D33;
21905 readonly MAX_VIEWPORT_DIMS: 0x0D3A;
21906 readonly SUBPIXEL_BITS: 0x0D50;
21907 readonly RED_BITS: 0x0D52;
21908 readonly GREEN_BITS: 0x0D53;
21909 readonly BLUE_BITS: 0x0D54;
21910 readonly ALPHA_BITS: 0x0D55;
21911 readonly DEPTH_BITS: 0x0D56;
21912 readonly STENCIL_BITS: 0x0D57;
21913 readonly POLYGON_OFFSET_UNITS: 0x2A00;
21914 readonly POLYGON_OFFSET_FACTOR: 0x8038;
21915 readonly TEXTURE_BINDING_2D: 0x8069;
21916 readonly SAMPLE_BUFFERS: 0x80A8;
21917 readonly SAMPLES: 0x80A9;
21918 readonly SAMPLE_COVERAGE_VALUE: 0x80AA;
21919 readonly SAMPLE_COVERAGE_INVERT: 0x80AB;
21920 readonly COMPRESSED_TEXTURE_FORMATS: 0x86A3;
21921 readonly DONT_CARE: 0x1100;
21922 readonly FASTEST: 0x1101;
21923 readonly NICEST: 0x1102;
21924 readonly GENERATE_MIPMAP_HINT: 0x8192;
21925 readonly BYTE: 0x1400;
21926 readonly UNSIGNED_BYTE: 0x1401;
21927 readonly SHORT: 0x1402;
21928 readonly UNSIGNED_SHORT: 0x1403;
21929 readonly INT: 0x1404;
21930 readonly UNSIGNED_INT: 0x1405;
21931 readonly FLOAT: 0x1406;
21932 readonly DEPTH_COMPONENT: 0x1902;
21933 readonly ALPHA: 0x1906;
21934 readonly RGB: 0x1907;
21935 readonly RGBA: 0x1908;
21936 readonly LUMINANCE: 0x1909;
21937 readonly LUMINANCE_ALPHA: 0x190A;
21938 readonly UNSIGNED_SHORT_4_4_4_4: 0x8033;
21939 readonly UNSIGNED_SHORT_5_5_5_1: 0x8034;
21940 readonly UNSIGNED_SHORT_5_6_5: 0x8363;
21941 readonly FRAGMENT_SHADER: 0x8B30;
21942 readonly VERTEX_SHADER: 0x8B31;
21943 readonly MAX_VERTEX_ATTRIBS: 0x8869;
21944 readonly MAX_VERTEX_UNIFORM_VECTORS: 0x8DFB;
21945 readonly MAX_VARYING_VECTORS: 0x8DFC;
21946 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8B4D;
21947 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8B4C;
21948 readonly MAX_TEXTURE_IMAGE_UNITS: 0x8872;
21949 readonly MAX_FRAGMENT_UNIFORM_VECTORS: 0x8DFD;
21950 readonly SHADER_TYPE: 0x8B4F;
21951 readonly DELETE_STATUS: 0x8B80;
21952 readonly LINK_STATUS: 0x8B82;
21953 readonly VALIDATE_STATUS: 0x8B83;
21954 readonly ATTACHED_SHADERS: 0x8B85;
21955 readonly ACTIVE_UNIFORMS: 0x8B86;
21956 readonly ACTIVE_ATTRIBUTES: 0x8B89;
21957 readonly SHADING_LANGUAGE_VERSION: 0x8B8C;
21958 readonly CURRENT_PROGRAM: 0x8B8D;
21959 readonly NEVER: 0x0200;
21960 readonly LESS: 0x0201;
21961 readonly EQUAL: 0x0202;
21962 readonly LEQUAL: 0x0203;
21963 readonly GREATER: 0x0204;
21964 readonly NOTEQUAL: 0x0205;
21965 readonly GEQUAL: 0x0206;
21966 readonly ALWAYS: 0x0207;
21967 readonly KEEP: 0x1E00;
21968 readonly REPLACE: 0x1E01;
21969 readonly INCR: 0x1E02;
21970 readonly DECR: 0x1E03;
21971 readonly INVERT: 0x150A;
21972 readonly INCR_WRAP: 0x8507;
21973 readonly DECR_WRAP: 0x8508;
21974 readonly VENDOR: 0x1F00;
21975 readonly RENDERER: 0x1F01;
21976 readonly VERSION: 0x1F02;
21977 readonly NEAREST: 0x2600;
21978 readonly LINEAR: 0x2601;
21979 readonly NEAREST_MIPMAP_NEAREST: 0x2700;
21980 readonly LINEAR_MIPMAP_NEAREST: 0x2701;
21981 readonly NEAREST_MIPMAP_LINEAR: 0x2702;
21982 readonly LINEAR_MIPMAP_LINEAR: 0x2703;
21983 readonly TEXTURE_MAG_FILTER: 0x2800;
21984 readonly TEXTURE_MIN_FILTER: 0x2801;
21985 readonly TEXTURE_WRAP_S: 0x2802;
21986 readonly TEXTURE_WRAP_T: 0x2803;
21987 readonly TEXTURE_2D: 0x0DE1;
21988 readonly TEXTURE: 0x1702;
21989 readonly TEXTURE_CUBE_MAP: 0x8513;
21990 readonly TEXTURE_BINDING_CUBE_MAP: 0x8514;
21991 readonly TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515;
21992 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516;
21993 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517;
21994 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518;
21995 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519;
21996 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851A;
21997 readonly MAX_CUBE_MAP_TEXTURE_SIZE: 0x851C;
21998 readonly TEXTURE0: 0x84C0;
21999 readonly TEXTURE1: 0x84C1;
22000 readonly TEXTURE2: 0x84C2;
22001 readonly TEXTURE3: 0x84C3;
22002 readonly TEXTURE4: 0x84C4;
22003 readonly TEXTURE5: 0x84C5;
22004 readonly TEXTURE6: 0x84C6;
22005 readonly TEXTURE7: 0x84C7;
22006 readonly TEXTURE8: 0x84C8;
22007 readonly TEXTURE9: 0x84C9;
22008 readonly TEXTURE10: 0x84CA;
22009 readonly TEXTURE11: 0x84CB;
22010 readonly TEXTURE12: 0x84CC;
22011 readonly TEXTURE13: 0x84CD;
22012 readonly TEXTURE14: 0x84CE;
22013 readonly TEXTURE15: 0x84CF;
22014 readonly TEXTURE16: 0x84D0;
22015 readonly TEXTURE17: 0x84D1;
22016 readonly TEXTURE18: 0x84D2;
22017 readonly TEXTURE19: 0x84D3;
22018 readonly TEXTURE20: 0x84D4;
22019 readonly TEXTURE21: 0x84D5;
22020 readonly TEXTURE22: 0x84D6;
22021 readonly TEXTURE23: 0x84D7;
22022 readonly TEXTURE24: 0x84D8;
22023 readonly TEXTURE25: 0x84D9;
22024 readonly TEXTURE26: 0x84DA;
22025 readonly TEXTURE27: 0x84DB;
22026 readonly TEXTURE28: 0x84DC;
22027 readonly TEXTURE29: 0x84DD;
22028 readonly TEXTURE30: 0x84DE;
22029 readonly TEXTURE31: 0x84DF;
22030 readonly ACTIVE_TEXTURE: 0x84E0;
22031 readonly REPEAT: 0x2901;
22032 readonly CLAMP_TO_EDGE: 0x812F;
22033 readonly MIRRORED_REPEAT: 0x8370;
22034 readonly FLOAT_VEC2: 0x8B50;
22035 readonly FLOAT_VEC3: 0x8B51;
22036 readonly FLOAT_VEC4: 0x8B52;
22037 readonly INT_VEC2: 0x8B53;
22038 readonly INT_VEC3: 0x8B54;
22039 readonly INT_VEC4: 0x8B55;
22040 readonly BOOL: 0x8B56;
22041 readonly BOOL_VEC2: 0x8B57;
22042 readonly BOOL_VEC3: 0x8B58;
22043 readonly BOOL_VEC4: 0x8B59;
22044 readonly FLOAT_MAT2: 0x8B5A;
22045 readonly FLOAT_MAT3: 0x8B5B;
22046 readonly FLOAT_MAT4: 0x8B5C;
22047 readonly SAMPLER_2D: 0x8B5E;
22048 readonly SAMPLER_CUBE: 0x8B60;
22049 readonly VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622;
22050 readonly VERTEX_ATTRIB_ARRAY_SIZE: 0x8623;
22051 readonly VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624;
22052 readonly VERTEX_ATTRIB_ARRAY_TYPE: 0x8625;
22053 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886A;
22054 readonly VERTEX_ATTRIB_ARRAY_POINTER: 0x8645;
22055 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889F;
22056 readonly IMPLEMENTATION_COLOR_READ_TYPE: 0x8B9A;
22057 readonly IMPLEMENTATION_COLOR_READ_FORMAT: 0x8B9B;
22058 readonly COMPILE_STATUS: 0x8B81;
22059 readonly LOW_FLOAT: 0x8DF0;
22060 readonly MEDIUM_FLOAT: 0x8DF1;
22061 readonly HIGH_FLOAT: 0x8DF2;
22062 readonly LOW_INT: 0x8DF3;
22063 readonly MEDIUM_INT: 0x8DF4;
22064 readonly HIGH_INT: 0x8DF5;
22065 readonly FRAMEBUFFER: 0x8D40;
22066 readonly RENDERBUFFER: 0x8D41;
22067 readonly RGBA4: 0x8056;
22068 readonly RGB5_A1: 0x8057;
22069 readonly RGB565: 0x8D62;
22070 readonly DEPTH_COMPONENT16: 0x81A5;
22071 readonly STENCIL_INDEX8: 0x8D48;
22072 readonly DEPTH_STENCIL: 0x84F9;
22073 readonly RENDERBUFFER_WIDTH: 0x8D42;
22074 readonly RENDERBUFFER_HEIGHT: 0x8D43;
22075 readonly RENDERBUFFER_INTERNAL_FORMAT: 0x8D44;
22076 readonly RENDERBUFFER_RED_SIZE: 0x8D50;
22077 readonly RENDERBUFFER_GREEN_SIZE: 0x8D51;
22078 readonly RENDERBUFFER_BLUE_SIZE: 0x8D52;
22079 readonly RENDERBUFFER_ALPHA_SIZE: 0x8D53;
22080 readonly RENDERBUFFER_DEPTH_SIZE: 0x8D54;
22081 readonly RENDERBUFFER_STENCIL_SIZE: 0x8D55;
22082 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8CD0;
22083 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8CD1;
22084 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8CD2;
22085 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8CD3;
22086 readonly COLOR_ATTACHMENT0: 0x8CE0;
22087 readonly DEPTH_ATTACHMENT: 0x8D00;
22088 readonly STENCIL_ATTACHMENT: 0x8D20;
22089 readonly DEPTH_STENCIL_ATTACHMENT: 0x821A;
22091 readonly FRAMEBUFFER_COMPLETE: 0x8CD5;
22092 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8CD6;
22093 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8CD7;
22094 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8CD9;
22095 readonly FRAMEBUFFER_UNSUPPORTED: 0x8CDD;
22096 readonly FRAMEBUFFER_BINDING: 0x8CA6;
22097 readonly RENDERBUFFER_BINDING: 0x8CA7;
22098 readonly MAX_RENDERBUFFER_SIZE: 0x84E8;
22099 readonly INVALID_FRAMEBUFFER_OPERATION: 0x0506;
22100 readonly UNPACK_FLIP_Y_WEBGL: 0x9240;
22101 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241;
22102 readonly CONTEXT_LOST_WEBGL: 0x9242;
22103 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243;
22104 readonly BROWSER_DEFAULT_WEBGL: 0x9244;
22105 isInstance: IsInstance<WebGLRenderingContext>;
22108 interface WebGLRenderingContextBase {
22109 readonly canvas: CanvasSource | null;
22110 drawingBufferColorSpace: PredefinedColorSpace;
22111 readonly drawingBufferHeight: GLsizei;
22112 readonly drawingBufferWidth: GLsizei;
22113 activeTexture(texture: GLenum): void;
22114 attachShader(program: WebGLProgram, shader: WebGLShader): void;
22115 bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void;
22116 bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void;
22117 bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void;
22118 bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
22119 bindTexture(target: GLenum, texture: WebGLTexture | null): void;
22120 blendColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat): void;
22121 blendEquation(mode: GLenum): void;
22122 blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void;
22123 blendFunc(sfactor: GLenum, dfactor: GLenum): void;
22124 blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void;
22125 checkFramebufferStatus(target: GLenum): GLenum;
22126 clear(mask: GLbitfield): void;
22127 clearColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat): void;
22128 clearDepth(depth: GLclampf): void;
22129 clearStencil(s: GLint): void;
22130 colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void;
22131 compileShader(shader: WebGLShader): void;
22132 copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void;
22133 copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
22134 createBuffer(): WebGLBuffer | null;
22135 createFramebuffer(): WebGLFramebuffer | null;
22136 createProgram(): WebGLProgram | null;
22137 createRenderbuffer(): WebGLRenderbuffer | null;
22138 createShader(type: GLenum): WebGLShader | null;
22139 createTexture(): WebGLTexture | null;
22140 cullFace(mode: GLenum): void;
22141 deleteBuffer(buffer: WebGLBuffer | null): void;
22142 deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void;
22143 deleteProgram(program: WebGLProgram | null): void;
22144 deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void;
22145 deleteShader(shader: WebGLShader | null): void;
22146 deleteTexture(texture: WebGLTexture | null): void;
22147 depthFunc(func: GLenum): void;
22148 depthMask(flag: GLboolean): void;
22149 depthRange(zNear: GLclampf, zFar: GLclampf): void;
22150 detachShader(program: WebGLProgram, shader: WebGLShader): void;
22151 disable(cap: GLenum): void;
22152 disableVertexAttribArray(index: GLuint): void;
22153 drawArrays(mode: GLenum, first: GLint, count: GLsizei): void;
22154 drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
22155 enable(cap: GLenum): void;
22156 enableVertexAttribArray(index: GLuint): void;
22159 framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void;
22160 framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void;
22161 frontFace(mode: GLenum): void;
22162 generateMipmap(target: GLenum): void;
22163 getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
22164 getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null;
22165 getAttachedShaders(program: WebGLProgram): WebGLShader[] | null;
22166 getAttribLocation(program: WebGLProgram, name: string): GLint;
22167 getBufferParameter(target: GLenum, pname: GLenum): any;
22168 getContextAttributes(): WebGLContextAttributes | null;
22169 getError(): GLenum;
22170 getExtension(name: string): any;
22171 getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any;
22172 getParameter(pname: GLenum): any;
22173 getProgramInfoLog(program: WebGLProgram): string | null;
22174 getProgramParameter(program: WebGLProgram, pname: GLenum): any;
22175 getRenderbufferParameter(target: GLenum, pname: GLenum): any;
22176 getShaderInfoLog(shader: WebGLShader): string | null;
22177 getShaderParameter(shader: WebGLShader, pname: GLenum): any;
22178 getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null;
22179 getShaderSource(shader: WebGLShader): string | null;
22180 getSupportedExtensions(): string[] | null;
22181 getTexParameter(target: GLenum, pname: GLenum): any;
22182 getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
22183 getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
22184 getVertexAttrib(index: GLuint, pname: GLenum): any;
22185 getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr;
22186 hint(target: GLenum, mode: GLenum): void;
22187 isBuffer(buffer: WebGLBuffer | null): GLboolean;
22188 isContextLost(): boolean;
22189 isEnabled(cap: GLenum): GLboolean;
22190 isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean;
22191 isProgram(program: WebGLProgram | null): GLboolean;
22192 isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean;
22193 isShader(shader: WebGLShader | null): GLboolean;
22194 isTexture(texture: WebGLTexture | null): GLboolean;
22195 lineWidth(width: GLfloat): void;
22196 linkProgram(program: WebGLProgram): void;
22197 makeXRCompatible(): Promise<void>;
22198 pixelStorei(pname: GLenum, param: GLint): void;
22199 polygonOffset(factor: GLfloat, units: GLfloat): void;
22200 renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
22201 sampleCoverage(value: GLclampf, invert: GLboolean): void;
22202 scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
22203 shaderSource(shader: WebGLShader, source: string): void;
22204 stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void;
22205 stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void;
22206 stencilMask(mask: GLuint): void;
22207 stencilMaskSeparate(face: GLenum, mask: GLuint): void;
22208 stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void;
22209 stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void;
22210 texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void;
22211 texParameteri(target: GLenum, pname: GLenum, param: GLint): void;
22212 uniform1f(location: WebGLUniformLocation | null, x: GLfloat): void;
22213 uniform1i(location: WebGLUniformLocation | null, x: GLint): void;
22214 uniform2f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat): void;
22215 uniform2i(location: WebGLUniformLocation | null, x: GLint, y: GLint): void;
22216 uniform3f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat): void;
22217 uniform3i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint): void;
22218 uniform4f(location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
22219 uniform4i(location: WebGLUniformLocation | null, x: GLint, y: GLint, z: GLint, w: GLint): void;
22220 useProgram(program: WebGLProgram | null): void;
22221 validateProgram(program: WebGLProgram): void;
22222 vertexAttrib1f(indx: GLuint, x: GLfloat): void;
22223 vertexAttrib1fv(indx: GLuint, values: Float32List): void;
22224 vertexAttrib2f(indx: GLuint, x: GLfloat, y: GLfloat): void;
22225 vertexAttrib2fv(indx: GLuint, values: Float32List): void;
22226 vertexAttrib3f(indx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void;
22227 vertexAttrib3fv(indx: GLuint, values: Float32List): void;
22228 vertexAttrib4f(indx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void;
22229 vertexAttrib4fv(indx: GLuint, values: Float32List): void;
22230 vertexAttribPointer(indx: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
22231 viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
22232 readonly DEPTH_BUFFER_BIT: 0x00000100;
22233 readonly STENCIL_BUFFER_BIT: 0x00000400;
22234 readonly COLOR_BUFFER_BIT: 0x00004000;
22235 readonly POINTS: 0x0000;
22236 readonly LINES: 0x0001;
22237 readonly LINE_LOOP: 0x0002;
22238 readonly LINE_STRIP: 0x0003;
22239 readonly TRIANGLES: 0x0004;
22240 readonly TRIANGLE_STRIP: 0x0005;
22241 readonly TRIANGLE_FAN: 0x0006;
22244 readonly SRC_COLOR: 0x0300;
22245 readonly ONE_MINUS_SRC_COLOR: 0x0301;
22246 readonly SRC_ALPHA: 0x0302;
22247 readonly ONE_MINUS_SRC_ALPHA: 0x0303;
22248 readonly DST_ALPHA: 0x0304;
22249 readonly ONE_MINUS_DST_ALPHA: 0x0305;
22250 readonly DST_COLOR: 0x0306;
22251 readonly ONE_MINUS_DST_COLOR: 0x0307;
22252 readonly SRC_ALPHA_SATURATE: 0x0308;
22253 readonly FUNC_ADD: 0x8006;
22254 readonly BLEND_EQUATION: 0x8009;
22255 readonly BLEND_EQUATION_RGB: 0x8009;
22256 readonly BLEND_EQUATION_ALPHA: 0x883D;
22257 readonly FUNC_SUBTRACT: 0x800A;
22258 readonly FUNC_REVERSE_SUBTRACT: 0x800B;
22259 readonly BLEND_DST_RGB: 0x80C8;
22260 readonly BLEND_SRC_RGB: 0x80C9;
22261 readonly BLEND_DST_ALPHA: 0x80CA;
22262 readonly BLEND_SRC_ALPHA: 0x80CB;
22263 readonly CONSTANT_COLOR: 0x8001;
22264 readonly ONE_MINUS_CONSTANT_COLOR: 0x8002;
22265 readonly CONSTANT_ALPHA: 0x8003;
22266 readonly ONE_MINUS_CONSTANT_ALPHA: 0x8004;
22267 readonly BLEND_COLOR: 0x8005;
22268 readonly ARRAY_BUFFER: 0x8892;
22269 readonly ELEMENT_ARRAY_BUFFER: 0x8893;
22270 readonly ARRAY_BUFFER_BINDING: 0x8894;
22271 readonly ELEMENT_ARRAY_BUFFER_BINDING: 0x8895;
22272 readonly STREAM_DRAW: 0x88E0;
22273 readonly STATIC_DRAW: 0x88E4;
22274 readonly DYNAMIC_DRAW: 0x88E8;
22275 readonly BUFFER_SIZE: 0x8764;
22276 readonly BUFFER_USAGE: 0x8765;
22277 readonly CURRENT_VERTEX_ATTRIB: 0x8626;
22278 readonly FRONT: 0x0404;
22279 readonly BACK: 0x0405;
22280 readonly FRONT_AND_BACK: 0x0408;
22281 readonly CULL_FACE: 0x0B44;
22282 readonly BLEND: 0x0BE2;
22283 readonly DITHER: 0x0BD0;
22284 readonly STENCIL_TEST: 0x0B90;
22285 readonly DEPTH_TEST: 0x0B71;
22286 readonly SCISSOR_TEST: 0x0C11;
22287 readonly POLYGON_OFFSET_FILL: 0x8037;
22288 readonly SAMPLE_ALPHA_TO_COVERAGE: 0x809E;
22289 readonly SAMPLE_COVERAGE: 0x80A0;
22290 readonly NO_ERROR: 0;
22291 readonly INVALID_ENUM: 0x0500;
22292 readonly INVALID_VALUE: 0x0501;
22293 readonly INVALID_OPERATION: 0x0502;
22294 readonly OUT_OF_MEMORY: 0x0505;
22295 readonly CW: 0x0900;
22296 readonly CCW: 0x0901;
22297 readonly LINE_WIDTH: 0x0B21;
22298 readonly ALIASED_POINT_SIZE_RANGE: 0x846D;
22299 readonly ALIASED_LINE_WIDTH_RANGE: 0x846E;
22300 readonly CULL_FACE_MODE: 0x0B45;
22301 readonly FRONT_FACE: 0x0B46;
22302 readonly DEPTH_RANGE: 0x0B70;
22303 readonly DEPTH_WRITEMASK: 0x0B72;
22304 readonly DEPTH_CLEAR_VALUE: 0x0B73;
22305 readonly DEPTH_FUNC: 0x0B74;
22306 readonly STENCIL_CLEAR_VALUE: 0x0B91;
22307 readonly STENCIL_FUNC: 0x0B92;
22308 readonly STENCIL_FAIL: 0x0B94;
22309 readonly STENCIL_PASS_DEPTH_FAIL: 0x0B95;
22310 readonly STENCIL_PASS_DEPTH_PASS: 0x0B96;
22311 readonly STENCIL_REF: 0x0B97;
22312 readonly STENCIL_VALUE_MASK: 0x0B93;
22313 readonly STENCIL_WRITEMASK: 0x0B98;
22314 readonly STENCIL_BACK_FUNC: 0x8800;
22315 readonly STENCIL_BACK_FAIL: 0x8801;
22316 readonly STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802;
22317 readonly STENCIL_BACK_PASS_DEPTH_PASS: 0x8803;
22318 readonly STENCIL_BACK_REF: 0x8CA3;
22319 readonly STENCIL_BACK_VALUE_MASK: 0x8CA4;
22320 readonly STENCIL_BACK_WRITEMASK: 0x8CA5;
22321 readonly VIEWPORT: 0x0BA2;
22322 readonly SCISSOR_BOX: 0x0C10;
22323 readonly COLOR_CLEAR_VALUE: 0x0C22;
22324 readonly COLOR_WRITEMASK: 0x0C23;
22325 readonly UNPACK_ALIGNMENT: 0x0CF5;
22326 readonly PACK_ALIGNMENT: 0x0D05;
22327 readonly MAX_TEXTURE_SIZE: 0x0D33;
22328 readonly MAX_VIEWPORT_DIMS: 0x0D3A;
22329 readonly SUBPIXEL_BITS: 0x0D50;
22330 readonly RED_BITS: 0x0D52;
22331 readonly GREEN_BITS: 0x0D53;
22332 readonly BLUE_BITS: 0x0D54;
22333 readonly ALPHA_BITS: 0x0D55;
22334 readonly DEPTH_BITS: 0x0D56;
22335 readonly STENCIL_BITS: 0x0D57;
22336 readonly POLYGON_OFFSET_UNITS: 0x2A00;
22337 readonly POLYGON_OFFSET_FACTOR: 0x8038;
22338 readonly TEXTURE_BINDING_2D: 0x8069;
22339 readonly SAMPLE_BUFFERS: 0x80A8;
22340 readonly SAMPLES: 0x80A9;
22341 readonly SAMPLE_COVERAGE_VALUE: 0x80AA;
22342 readonly SAMPLE_COVERAGE_INVERT: 0x80AB;
22343 readonly COMPRESSED_TEXTURE_FORMATS: 0x86A3;
22344 readonly DONT_CARE: 0x1100;
22345 readonly FASTEST: 0x1101;
22346 readonly NICEST: 0x1102;
22347 readonly GENERATE_MIPMAP_HINT: 0x8192;
22348 readonly BYTE: 0x1400;
22349 readonly UNSIGNED_BYTE: 0x1401;
22350 readonly SHORT: 0x1402;
22351 readonly UNSIGNED_SHORT: 0x1403;
22352 readonly INT: 0x1404;
22353 readonly UNSIGNED_INT: 0x1405;
22354 readonly FLOAT: 0x1406;
22355 readonly DEPTH_COMPONENT: 0x1902;
22356 readonly ALPHA: 0x1906;
22357 readonly RGB: 0x1907;
22358 readonly RGBA: 0x1908;
22359 readonly LUMINANCE: 0x1909;
22360 readonly LUMINANCE_ALPHA: 0x190A;
22361 readonly UNSIGNED_SHORT_4_4_4_4: 0x8033;
22362 readonly UNSIGNED_SHORT_5_5_5_1: 0x8034;
22363 readonly UNSIGNED_SHORT_5_6_5: 0x8363;
22364 readonly FRAGMENT_SHADER: 0x8B30;
22365 readonly VERTEX_SHADER: 0x8B31;
22366 readonly MAX_VERTEX_ATTRIBS: 0x8869;
22367 readonly MAX_VERTEX_UNIFORM_VECTORS: 0x8DFB;
22368 readonly MAX_VARYING_VECTORS: 0x8DFC;
22369 readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8B4D;
22370 readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8B4C;
22371 readonly MAX_TEXTURE_IMAGE_UNITS: 0x8872;
22372 readonly MAX_FRAGMENT_UNIFORM_VECTORS: 0x8DFD;
22373 readonly SHADER_TYPE: 0x8B4F;
22374 readonly DELETE_STATUS: 0x8B80;
22375 readonly LINK_STATUS: 0x8B82;
22376 readonly VALIDATE_STATUS: 0x8B83;
22377 readonly ATTACHED_SHADERS: 0x8B85;
22378 readonly ACTIVE_UNIFORMS: 0x8B86;
22379 readonly ACTIVE_ATTRIBUTES: 0x8B89;
22380 readonly SHADING_LANGUAGE_VERSION: 0x8B8C;
22381 readonly CURRENT_PROGRAM: 0x8B8D;
22382 readonly NEVER: 0x0200;
22383 readonly LESS: 0x0201;
22384 readonly EQUAL: 0x0202;
22385 readonly LEQUAL: 0x0203;
22386 readonly GREATER: 0x0204;
22387 readonly NOTEQUAL: 0x0205;
22388 readonly GEQUAL: 0x0206;
22389 readonly ALWAYS: 0x0207;
22390 readonly KEEP: 0x1E00;
22391 readonly REPLACE: 0x1E01;
22392 readonly INCR: 0x1E02;
22393 readonly DECR: 0x1E03;
22394 readonly INVERT: 0x150A;
22395 readonly INCR_WRAP: 0x8507;
22396 readonly DECR_WRAP: 0x8508;
22397 readonly VENDOR: 0x1F00;
22398 readonly RENDERER: 0x1F01;
22399 readonly VERSION: 0x1F02;
22400 readonly NEAREST: 0x2600;
22401 readonly LINEAR: 0x2601;
22402 readonly NEAREST_MIPMAP_NEAREST: 0x2700;
22403 readonly LINEAR_MIPMAP_NEAREST: 0x2701;
22404 readonly NEAREST_MIPMAP_LINEAR: 0x2702;
22405 readonly LINEAR_MIPMAP_LINEAR: 0x2703;
22406 readonly TEXTURE_MAG_FILTER: 0x2800;
22407 readonly TEXTURE_MIN_FILTER: 0x2801;
22408 readonly TEXTURE_WRAP_S: 0x2802;
22409 readonly TEXTURE_WRAP_T: 0x2803;
22410 readonly TEXTURE_2D: 0x0DE1;
22411 readonly TEXTURE: 0x1702;
22412 readonly TEXTURE_CUBE_MAP: 0x8513;
22413 readonly TEXTURE_BINDING_CUBE_MAP: 0x8514;
22414 readonly TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515;
22415 readonly TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516;
22416 readonly TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517;
22417 readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518;
22418 readonly TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519;
22419 readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851A;
22420 readonly MAX_CUBE_MAP_TEXTURE_SIZE: 0x851C;
22421 readonly TEXTURE0: 0x84C0;
22422 readonly TEXTURE1: 0x84C1;
22423 readonly TEXTURE2: 0x84C2;
22424 readonly TEXTURE3: 0x84C3;
22425 readonly TEXTURE4: 0x84C4;
22426 readonly TEXTURE5: 0x84C5;
22427 readonly TEXTURE6: 0x84C6;
22428 readonly TEXTURE7: 0x84C7;
22429 readonly TEXTURE8: 0x84C8;
22430 readonly TEXTURE9: 0x84C9;
22431 readonly TEXTURE10: 0x84CA;
22432 readonly TEXTURE11: 0x84CB;
22433 readonly TEXTURE12: 0x84CC;
22434 readonly TEXTURE13: 0x84CD;
22435 readonly TEXTURE14: 0x84CE;
22436 readonly TEXTURE15: 0x84CF;
22437 readonly TEXTURE16: 0x84D0;
22438 readonly TEXTURE17: 0x84D1;
22439 readonly TEXTURE18: 0x84D2;
22440 readonly TEXTURE19: 0x84D3;
22441 readonly TEXTURE20: 0x84D4;
22442 readonly TEXTURE21: 0x84D5;
22443 readonly TEXTURE22: 0x84D6;
22444 readonly TEXTURE23: 0x84D7;
22445 readonly TEXTURE24: 0x84D8;
22446 readonly TEXTURE25: 0x84D9;
22447 readonly TEXTURE26: 0x84DA;
22448 readonly TEXTURE27: 0x84DB;
22449 readonly TEXTURE28: 0x84DC;
22450 readonly TEXTURE29: 0x84DD;
22451 readonly TEXTURE30: 0x84DE;
22452 readonly TEXTURE31: 0x84DF;
22453 readonly ACTIVE_TEXTURE: 0x84E0;
22454 readonly REPEAT: 0x2901;
22455 readonly CLAMP_TO_EDGE: 0x812F;
22456 readonly MIRRORED_REPEAT: 0x8370;
22457 readonly FLOAT_VEC2: 0x8B50;
22458 readonly FLOAT_VEC3: 0x8B51;
22459 readonly FLOAT_VEC4: 0x8B52;
22460 readonly INT_VEC2: 0x8B53;
22461 readonly INT_VEC3: 0x8B54;
22462 readonly INT_VEC4: 0x8B55;
22463 readonly BOOL: 0x8B56;
22464 readonly BOOL_VEC2: 0x8B57;
22465 readonly BOOL_VEC3: 0x8B58;
22466 readonly BOOL_VEC4: 0x8B59;
22467 readonly FLOAT_MAT2: 0x8B5A;
22468 readonly FLOAT_MAT3: 0x8B5B;
22469 readonly FLOAT_MAT4: 0x8B5C;
22470 readonly SAMPLER_2D: 0x8B5E;
22471 readonly SAMPLER_CUBE: 0x8B60;
22472 readonly VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622;
22473 readonly VERTEX_ATTRIB_ARRAY_SIZE: 0x8623;
22474 readonly VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624;
22475 readonly VERTEX_ATTRIB_ARRAY_TYPE: 0x8625;
22476 readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886A;
22477 readonly VERTEX_ATTRIB_ARRAY_POINTER: 0x8645;
22478 readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889F;
22479 readonly IMPLEMENTATION_COLOR_READ_TYPE: 0x8B9A;
22480 readonly IMPLEMENTATION_COLOR_READ_FORMAT: 0x8B9B;
22481 readonly COMPILE_STATUS: 0x8B81;
22482 readonly LOW_FLOAT: 0x8DF0;
22483 readonly MEDIUM_FLOAT: 0x8DF1;
22484 readonly HIGH_FLOAT: 0x8DF2;
22485 readonly LOW_INT: 0x8DF3;
22486 readonly MEDIUM_INT: 0x8DF4;
22487 readonly HIGH_INT: 0x8DF5;
22488 readonly FRAMEBUFFER: 0x8D40;
22489 readonly RENDERBUFFER: 0x8D41;
22490 readonly RGBA4: 0x8056;
22491 readonly RGB5_A1: 0x8057;
22492 readonly RGB565: 0x8D62;
22493 readonly DEPTH_COMPONENT16: 0x81A5;
22494 readonly STENCIL_INDEX8: 0x8D48;
22495 readonly DEPTH_STENCIL: 0x84F9;
22496 readonly RENDERBUFFER_WIDTH: 0x8D42;
22497 readonly RENDERBUFFER_HEIGHT: 0x8D43;
22498 readonly RENDERBUFFER_INTERNAL_FORMAT: 0x8D44;
22499 readonly RENDERBUFFER_RED_SIZE: 0x8D50;
22500 readonly RENDERBUFFER_GREEN_SIZE: 0x8D51;
22501 readonly RENDERBUFFER_BLUE_SIZE: 0x8D52;
22502 readonly RENDERBUFFER_ALPHA_SIZE: 0x8D53;
22503 readonly RENDERBUFFER_DEPTH_SIZE: 0x8D54;
22504 readonly RENDERBUFFER_STENCIL_SIZE: 0x8D55;
22505 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8CD0;
22506 readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8CD1;
22507 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8CD2;
22508 readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8CD3;
22509 readonly COLOR_ATTACHMENT0: 0x8CE0;
22510 readonly DEPTH_ATTACHMENT: 0x8D00;
22511 readonly STENCIL_ATTACHMENT: 0x8D20;
22512 readonly DEPTH_STENCIL_ATTACHMENT: 0x821A;
22514 readonly FRAMEBUFFER_COMPLETE: 0x8CD5;
22515 readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8CD6;
22516 readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8CD7;
22517 readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8CD9;
22518 readonly FRAMEBUFFER_UNSUPPORTED: 0x8CDD;
22519 readonly FRAMEBUFFER_BINDING: 0x8CA6;
22520 readonly RENDERBUFFER_BINDING: 0x8CA7;
22521 readonly MAX_RENDERBUFFER_SIZE: 0x84E8;
22522 readonly INVALID_FRAMEBUFFER_OPERATION: 0x0506;
22523 readonly UNPACK_FLIP_Y_WEBGL: 0x9240;
22524 readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241;
22525 readonly CONTEXT_LOST_WEBGL: 0x9242;
22526 readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243;
22527 readonly BROWSER_DEFAULT_WEBGL: 0x9244;
22530 interface WebGLSampler {
22533 declare var WebGLSampler: {
22534 prototype: WebGLSampler;
22535 new(): WebGLSampler;
22536 isInstance: IsInstance<WebGLSampler>;
22539 interface WebGLShader {
22542 declare var WebGLShader: {
22543 prototype: WebGLShader;
22544 new(): WebGLShader;
22545 isInstance: IsInstance<WebGLShader>;
22548 interface WebGLShaderPrecisionFormat {
22549 readonly precision: GLint;
22550 readonly rangeMax: GLint;
22551 readonly rangeMin: GLint;
22554 declare var WebGLShaderPrecisionFormat: {
22555 prototype: WebGLShaderPrecisionFormat;
22556 new(): WebGLShaderPrecisionFormat;
22557 isInstance: IsInstance<WebGLShaderPrecisionFormat>;
22560 interface WebGLSync {
22563 declare var WebGLSync: {
22564 prototype: WebGLSync;
22566 isInstance: IsInstance<WebGLSync>;
22569 interface WebGLTexture {
22572 declare var WebGLTexture: {
22573 prototype: WebGLTexture;
22574 new(): WebGLTexture;
22575 isInstance: IsInstance<WebGLTexture>;
22578 interface WebGLTransformFeedback {
22581 declare var WebGLTransformFeedback: {
22582 prototype: WebGLTransformFeedback;
22583 new(): WebGLTransformFeedback;
22584 isInstance: IsInstance<WebGLTransformFeedback>;
22587 interface WebGLUniformLocation {
22590 declare var WebGLUniformLocation: {
22591 prototype: WebGLUniformLocation;
22592 new(): WebGLUniformLocation;
22593 isInstance: IsInstance<WebGLUniformLocation>;
22596 interface WebGLVertexArrayObject {
22599 declare var WebGLVertexArrayObject: {
22600 prototype: WebGLVertexArrayObject;
22601 new(): WebGLVertexArrayObject;
22602 isInstance: IsInstance<WebGLVertexArrayObject>;
22605 interface WebSocketEventMap {
22612 interface WebSocket extends EventTarget {
22613 binaryType: BinaryType;
22614 readonly bufferedAmount: number;
22615 readonly extensions: string;
22616 onclose: ((this: WebSocket, ev: Event) => any) | null;
22617 onerror: ((this: WebSocket, ev: Event) => any) | null;
22618 onmessage: ((this: WebSocket, ev: Event) => any) | null;
22619 onopen: ((this: WebSocket, ev: Event) => any) | null;
22620 readonly protocol: string;
22621 readonly readyState: number;
22622 readonly url: string;
22623 close(code?: number, reason?: string): void;
22624 send(data: string): void;
22625 send(data: Blob): void;
22626 send(data: ArrayBuffer): void;
22627 send(data: ArrayBufferView): void;
22628 readonly CONNECTING: 0;
22630 readonly CLOSING: 2;
22631 readonly CLOSED: 3;
22632 addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
22633 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
22634 removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
22635 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
22638 declare var WebSocket: {
22639 prototype: WebSocket;
22640 new(url: string, protocols?: string | string[]): WebSocket;
22641 readonly CONNECTING: 0;
22643 readonly CLOSING: 2;
22644 readonly CLOSED: 3;
22645 isInstance: IsInstance<WebSocket>;
22646 createServerWebSocket(url: string, protocols: string[], transportProvider: nsITransportProvider, negotiatedExtensions: string): WebSocket;
22649 /** Available only in secure contexts. */
22650 interface WebTransport {
22651 readonly closed: Promise<WebTransportCloseInfo>;
22652 readonly congestionControl: WebTransportCongestionControl;
22653 readonly datagrams: WebTransportDatagramDuplexStream;
22654 readonly incomingBidirectionalStreams: ReadableStream;
22655 readonly incomingUnidirectionalStreams: ReadableStream;
22656 readonly ready: Promise<undefined>;
22657 readonly reliability: WebTransportReliabilityMode;
22658 close(closeInfo?: WebTransportCloseInfo): void;
22659 createBidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WebTransportBidirectionalStream>;
22660 createUnidirectionalStream(options?: WebTransportSendStreamOptions): Promise<WritableStream>;
22661 getStats(): Promise<WebTransportStats>;
22664 declare var WebTransport: {
22665 prototype: WebTransport;
22666 new(url: string | URL, options?: WebTransportOptions): WebTransport;
22667 isInstance: IsInstance<WebTransport>;
22670 /** Available only in secure contexts. */
22671 interface WebTransportBidirectionalStream {
22672 readonly readable: WebTransportReceiveStream;
22673 readonly writable: WebTransportSendStream;
22676 declare var WebTransportBidirectionalStream: {
22677 prototype: WebTransportBidirectionalStream;
22678 new(): WebTransportBidirectionalStream;
22679 isInstance: IsInstance<WebTransportBidirectionalStream>;
22682 /** Available only in secure contexts. */
22683 interface WebTransportDatagramDuplexStream {
22684 incomingHighWaterMark: number;
22685 incomingMaxAge: number;
22686 readonly maxDatagramSize: number;
22687 outgoingHighWaterMark: number;
22688 outgoingMaxAge: number;
22689 readonly readable: ReadableStream;
22690 readonly writable: WritableStream;
22693 declare var WebTransportDatagramDuplexStream: {
22694 prototype: WebTransportDatagramDuplexStream;
22695 new(): WebTransportDatagramDuplexStream;
22696 isInstance: IsInstance<WebTransportDatagramDuplexStream>;
22699 /** Available only in secure contexts. */
22700 interface WebTransportError extends DOMException {
22701 readonly source: WebTransportErrorSource;
22702 readonly streamErrorCode: number | null;
22705 declare var WebTransportError: {
22706 prototype: WebTransportError;
22707 new(init?: WebTransportErrorInit): WebTransportError;
22708 isInstance: IsInstance<WebTransportError>;
22711 /** Available only in secure contexts. */
22712 interface WebTransportReceiveStream extends ReadableStream {
22713 getStats(): Promise<WebTransportReceiveStreamStats>;
22716 declare var WebTransportReceiveStream: {
22717 prototype: WebTransportReceiveStream;
22718 new(): WebTransportReceiveStream;
22719 isInstance: IsInstance<WebTransportReceiveStream>;
22722 /** Available only in secure contexts. */
22723 interface WebTransportSendStream extends WritableStream {
22724 sendOrder: number | null;
22725 getStats(): Promise<WebTransportSendStreamStats>;
22728 declare var WebTransportSendStream: {
22729 prototype: WebTransportSendStream;
22730 new(): WebTransportSendStream;
22731 isInstance: IsInstance<WebTransportSendStream>;
22734 interface WheelEvent extends MouseEvent {
22735 readonly deltaMode: number;
22736 readonly deltaX: number;
22737 readonly deltaY: number;
22738 readonly deltaZ: number;
22739 readonly wheelDelta: number;
22740 readonly wheelDeltaX: number;
22741 readonly wheelDeltaY: number;
22742 readonly DOM_DELTA_PIXEL: 0x00;
22743 readonly DOM_DELTA_LINE: 0x01;
22744 readonly DOM_DELTA_PAGE: 0x02;
22747 declare var WheelEvent: {
22748 prototype: WheelEvent;
22749 new(type: string, eventInitDict?: WheelEventInit): WheelEvent;
22750 readonly DOM_DELTA_PIXEL: 0x00;
22751 readonly DOM_DELTA_LINE: 0x01;
22752 readonly DOM_DELTA_PAGE: 0x02;
22753 isInstance: IsInstance<WheelEvent>;
22756 interface WindowEventMap extends GlobalEventHandlersEventMap, OnErrorEventHandlerForWindowEventMap, TouchEventHandlersEventMap, WindowEventHandlersEventMap {
22757 "devicelight": Event;
22758 "devicemotion": Event;
22759 "deviceorientation": Event;
22760 "deviceorientationabsolute": Event;
22761 "orientationchange": Event;
22762 "userproximity": Event;
22763 "vrdisplayactivate": Event;
22764 "vrdisplayconnect": Event;
22765 "vrdisplaydeactivate": Event;
22766 "vrdisplaydisconnect": Event;
22767 "vrdisplaypresentchange": Event;
22770 interface Window extends EventTarget, AnimationFrameProvider, GlobalCrypto, GlobalEventHandlers, OnErrorEventHandlerForWindow, SpeechSynthesisGetter, TouchEventHandlers, WindowEventHandlers, WindowLocalStorage, WindowOrWorkerGlobalScope, WindowSessionStorage {
22771 readonly Glean: GleanImpl;
22772 readonly GleanPings: GleanPingsImpl;
22773 readonly InstallTrigger: InstallTriggerImpl | null;
22774 browserDOMWindow: nsIBrowserDOMWindow | null;
22775 readonly browsingContext: BrowsingContext;
22776 readonly clientInformation: Navigator;
22777 readonly clientPrincipal: Principal | null;
22778 readonly closed: boolean;
22779 readonly content: any;
22780 readonly controllers: XULControllers;
22781 readonly customElements: CustomElementRegistry;
22782 readonly desktopToDeviceScale: number;
22783 readonly devicePixelRatio: number;
22784 readonly docShell: nsIDocShell | null;
22785 readonly document: Document | null;
22786 readonly event: Event | undefined;
22787 readonly external: External;
22788 readonly frameElement: Element | null;
22789 readonly frames: WindowProxy;
22790 fullScreen: boolean;
22791 readonly history: History;
22792 readonly innerHeight: number;
22793 readonly innerWidth: number;
22794 readonly intlUtils: IntlUtils;
22795 readonly isChromeWindow: boolean;
22796 readonly isFullyOccluded: boolean;
22797 readonly isInFullScreenTransition: boolean;
22798 readonly length: number;
22799 readonly location: Location;
22800 readonly locationbar: BarProp;
22801 readonly menubar: BarProp;
22802 readonly messageManager: ChromeMessageBroadcaster;
22803 readonly mozInnerScreenX: number;
22804 readonly mozInnerScreenY: number;
22806 readonly navigator: Navigator;
22807 ondevicelight: ((this: Window, ev: Event) => any) | null;
22808 ondevicemotion: ((this: Window, ev: Event) => any) | null;
22809 ondeviceorientation: ((this: Window, ev: Event) => any) | null;
22810 ondeviceorientationabsolute: ((this: Window, ev: Event) => any) | null;
22811 onorientationchange: ((this: Window, ev: Event) => any) | null;
22812 onuserproximity: ((this: Window, ev: Event) => any) | null;
22813 onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
22814 onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
22815 onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
22816 onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
22817 onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
22819 readonly orientation: number;
22820 readonly outerHeight: number;
22821 readonly outerWidth: number;
22822 readonly pageXOffset: number;
22823 readonly pageYOffset: number;
22824 readonly paintWorklet: Worklet;
22825 readonly parent: WindowProxy | null;
22826 readonly performance: Performance | null;
22827 readonly personalbar: BarProp;
22828 readonly realFrameElement: Element | null;
22829 readonly screen: Screen;
22830 readonly screenEdgeSlopX: number;
22831 readonly screenEdgeSlopY: number;
22832 readonly screenLeft: number;
22833 readonly screenTop: number;
22834 readonly screenX: number;
22835 readonly screenY: number;
22836 readonly scrollMaxX: number;
22837 readonly scrollMaxY: number;
22838 readonly scrollMinX: number;
22839 readonly scrollMinY: number;
22840 readonly scrollX: number;
22841 readonly scrollY: number;
22842 readonly scrollbars: BarProp;
22843 readonly self: WindowProxy;
22845 readonly statusbar: BarProp;
22846 readonly toolbar: BarProp;
22847 readonly top: WindowProxy | null;
22848 readonly visualViewport: VisualViewport;
22849 readonly window: WindowProxy;
22850 readonly windowGlobalChild: WindowGlobalChild | null;
22851 readonly windowRoot: WindowRoot | null;
22852 readonly windowState: number;
22853 readonly windowUtils: nsIDOMWindowUtils;
22855 alert(message: string): void;
22857 cancelIdleCallback(handle: number): void;
22858 captureEvents(): void;
22860 confirm(message?: string): boolean;
22861 dump(str: string): void;
22862 find(str?: string, caseSensitive?: boolean, backwards?: boolean, wrapAround?: boolean, wholeWord?: boolean, searchInFrames?: boolean, showDialog?: boolean): boolean;
22864 getAttention(): void;
22865 getAttentionWithCycleCount(aCycleCount: number): void;
22866 getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration | null;
22867 getDefaultComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration | null;
22868 getGroupMessageManager(aGroup: string): ChromeMessageBroadcaster;
22869 getInterface(iid: any): any;
22870 getRegionalPrefsLocales(): string[];
22871 getSelection(): Selection | null;
22872 getWebExposedLocales(): string[];
22873 getWorkspaceID(): string;
22874 matchMedia(query: string): MediaQueryList | null;
22877 moveBy(x: number, y: number): void;
22878 moveTo(x: number, y: number): void;
22879 moveToWorkspace(workspaceID: string): void;
22880 mozScrollSnap(): void;
22881 notifyDefaultButtonLoaded(defaultButton: Element): void;
22882 open(url?: string | URL, target?: string, features?: string): WindowProxy | null;
22883 openDialog(url?: string, name?: string, options?: string, ...extraArguments: any[]): WindowProxy | null;
22884 postMessage(message: any, targetOrigin: string, transfer?: any[]): void;
22885 postMessage(message: any, options?: WindowPostMessageOptions): void;
22887 printPreview(settings?: nsIPrintSettings | null, listener?: nsIWebProgressListener | null, docShellToPreviewInto?: nsIDocShell | null): WindowProxy | null;
22888 promiseDocumentFlushed(callback: PromiseDocumentFlushedCallback): Promise<any>;
22889 prompt(message?: string, _default?: string): string | null;
22890 releaseEvents(): void;
22891 requestIdleCallback(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
22892 resizeBy(x: number, y: number): void;
22893 resizeTo(x: number, y: number): void;
22895 scroll(x: number, y: number): void;
22896 scroll(options?: ScrollToOptions): void;
22897 scrollBy(x: number, y: number): void;
22898 scrollBy(options?: ScrollToOptions): void;
22899 scrollByLines(numLines: number, options?: ScrollOptions): void;
22900 scrollByPages(numPages: number, options?: ScrollOptions): void;
22901 scrollTo(x: number, y: number): void;
22902 scrollTo(options?: ScrollToOptions): void;
22903 setCursor(cursor: string): void;
22904 setResizable(resizable: boolean): void;
22905 setScrollMarks(marks: number[], onHorizontalScrollbar?: boolean): void;
22906 shouldReportForServiceWorkerScope(aScope: string): boolean;
22907 sizeToContent(): void;
22908 sizeToContentConstrained(constraints?: SizeToContentConstraints): void;
22910 updateCommands(action: string): void;
22911 readonly STATE_MAXIMIZED: 1;
22912 readonly STATE_MINIMIZED: 2;
22913 readonly STATE_NORMAL: 3;
22914 readonly STATE_FULLSCREEN: 4;
22915 addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
22916 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
22917 removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
22918 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
22919 [name: string]: any;
22922 declare var Window: {
22925 readonly STATE_MAXIMIZED: 1;
22926 readonly STATE_MINIMIZED: 2;
22927 readonly STATE_NORMAL: 3;
22928 readonly STATE_FULLSCREEN: 4;
22929 isInstance: IsInstance<Window>;
22932 interface WindowContext {
22933 allowJavascript: boolean;
22934 readonly browsingContext: BrowsingContext | null;
22935 readonly hasBeforeUnload: boolean;
22936 readonly innerWindowId: number;
22937 readonly isInBFCache: boolean;
22938 readonly isInProcess: boolean;
22939 readonly isLocalIP: boolean;
22940 readonly overriddenFingerprintingSettings: number | null;
22941 readonly parentWindowContext: WindowContext | null;
22942 readonly shouldResistFingerprinting: boolean;
22943 readonly topWindowContext: WindowContext;
22944 readonly windowGlobalChild: WindowGlobalChild | null;
22947 declare var WindowContext: {
22948 prototype: WindowContext;
22949 new(): WindowContext;
22950 isInstance: IsInstance<WindowContext>;
22953 interface WindowEventHandlersEventMap {
22954 "afterprint": Event;
22955 "beforeprint": Event;
22956 "beforeunload": Event;
22957 "gamepadconnected": Event;
22958 "gamepaddisconnected": Event;
22959 "hashchange": Event;
22960 "languagechange": Event;
22962 "messageerror": Event;
22968 "rejectionhandled": Event;
22970 "unhandledrejection": Event;
22974 interface WindowEventHandlers {
22975 onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
22976 onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
22977 onbeforeunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
22978 ongamepadconnected: ((this: WindowEventHandlers, ev: Event) => any) | null;
22979 ongamepaddisconnected: ((this: WindowEventHandlers, ev: Event) => any) | null;
22980 onhashchange: ((this: WindowEventHandlers, ev: Event) => any) | null;
22981 onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
22982 onmessage: ((this: WindowEventHandlers, ev: Event) => any) | null;
22983 onmessageerror: ((this: WindowEventHandlers, ev: Event) => any) | null;
22984 onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
22985 ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
22986 onpagehide: ((this: WindowEventHandlers, ev: Event) => any) | null;
22987 onpageshow: ((this: WindowEventHandlers, ev: Event) => any) | null;
22988 onpopstate: ((this: WindowEventHandlers, ev: Event) => any) | null;
22989 onrejectionhandled: ((this: WindowEventHandlers, ev: Event) => any) | null;
22990 onstorage: ((this: WindowEventHandlers, ev: Event) => any) | null;
22991 onunhandledrejection: ((this: WindowEventHandlers, ev: Event) => any) | null;
22992 onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
22993 addEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
22994 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
22995 removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
22996 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
22999 interface WindowGlobalChild {
23000 readonly browsingContext: BrowsingContext;
23001 readonly contentParentId: number;
23002 readonly innerWindowId: number;
23003 readonly isClosed: boolean;
23004 readonly isCurrentGlobal: boolean;
23005 readonly isInProcess: boolean;
23006 readonly isProcessRoot: boolean;
23007 readonly outerWindowId: number;
23008 readonly parentActor: WindowGlobalParent | null;
23009 readonly sameOriginWithTop: boolean;
23010 readonly windowContext: WindowContext;
23011 findBrowsingContextWithName(name: string): BrowsingContext | null;
23012 getActor(name: string): JSWindowActorChild;
23013 getExistingActor(name: string): JSWindowActorChild | null;
23016 declare var WindowGlobalChild: {
23017 prototype: WindowGlobalChild;
23018 new(): WindowGlobalChild;
23019 isInstance: IsInstance<WindowGlobalChild>;
23020 getByInnerWindowId(innerWIndowId: number): WindowGlobalChild | null;
23023 interface WindowGlobalParent extends WindowContext {
23024 readonly childActor: WindowGlobalChild | null;
23025 readonly contentBlockingAllowListPrincipal: Principal | null;
23026 readonly contentBlockingEvents: number;
23027 readonly contentBlockingLog: string;
23028 readonly contentParentId: number;
23029 readonly cookieJarSettings: nsICookieJarSettings | null;
23030 readonly documentPrincipal: Principal;
23031 readonly documentStoragePrincipal: Principal;
23032 readonly documentTitle: string;
23033 readonly documentURI: URI | null;
23034 readonly domProcess: nsIDOMProcessParent | null;
23035 fullscreen: boolean;
23036 readonly isActiveInTab: boolean;
23037 readonly isClosed: boolean;
23038 readonly isCurrentGlobal: boolean;
23039 readonly isInitialDocument: boolean;
23040 readonly isProcessRoot: boolean;
23041 readonly osPid: number;
23042 readonly outerWindowId: number;
23043 readonly rootFrameLoader: FrameLoader | null;
23044 drawSnapshot(rect: DOMRect | null, scale: number, backgroundColor: string, resetScrollPosition?: boolean): Promise<ImageBitmap>;
23045 getActor(name: string): JSWindowActorParent;
23046 getExistingActor(name: string): JSWindowActorParent | null;
23047 hasActivePeerConnections(): boolean;
23048 permitUnload(action?: PermitUnloadAction, timeout?: number): Promise<boolean>;
23051 declare var WindowGlobalParent: {
23052 prototype: WindowGlobalParent;
23053 new(): WindowGlobalParent;
23054 isInstance: IsInstance<WindowGlobalParent>;
23055 getByInnerWindowId(innerWindowId: number): WindowGlobalParent | null;
23058 interface WindowLocalStorage {
23059 readonly localStorage: Storage | null;
23062 interface WindowOrWorkerGlobalScope {
23063 readonly caches: CacheStorage;
23064 readonly crossOriginIsolated: boolean;
23065 readonly indexedDB: IDBFactory | null;
23066 readonly isSecureContext: boolean;
23067 readonly origin: string;
23068 readonly scheduler: Scheduler;
23069 readonly trustedTypes: TrustedTypePolicyFactory;
23070 atob(atob: string): string;
23071 btoa(btoa: string): string;
23072 clearInterval(handle?: number): void;
23073 clearTimeout(handle?: number): void;
23074 createImageBitmap(aImage: ImageBitmapSource, aOptions?: ImageBitmapOptions): Promise<ImageBitmap>;
23075 createImageBitmap(aImage: ImageBitmapSource, aSx: number, aSy: number, aSw: number, aSh: number, aOptions?: ImageBitmapOptions): Promise<ImageBitmap>;
23076 fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
23077 queueMicrotask(callback: VoidFunction): void;
23078 reportError(e: any): void;
23079 setInterval(handler: Function, timeout?: number, ...arguments: any[]): number;
23080 setInterval(handler: string, timeout?: number, ...unused: any[]): number;
23081 setTimeout(handler: Function, timeout?: number, ...arguments: any[]): number;
23082 setTimeout(handler: string, timeout?: number, ...unused: any[]): number;
23083 structuredClone(value: any, options?: StructuredSerializeOptions): any;
23086 interface WindowProxy {
23089 interface WindowRoot extends EventTarget {
23092 declare var WindowRoot: {
23093 prototype: WindowRoot;
23095 isInstance: IsInstance<WindowRoot>;
23098 interface WindowSessionStorage {
23099 readonly sessionStorage: Storage | null;
23102 interface WorkerEventMap extends AbstractWorkerEventMap {
23104 "messageerror": Event;
23107 interface Worker extends EventTarget, AbstractWorker {
23108 onmessage: ((this: Worker, ev: Event) => any) | null;
23109 onmessageerror: ((this: Worker, ev: Event) => any) | null;
23110 postMessage(message: any, transfer: any[]): void;
23111 postMessage(message: any, aOptions?: StructuredSerializeOptions): void;
23113 addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23114 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23115 removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23116 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23119 declare var Worker: {
23121 new(scriptURL: string | URL, options?: WorkerOptions): Worker;
23122 isInstance: IsInstance<Worker>;
23125 /** Available only in secure contexts. */
23126 interface Worklet {
23127 addModule(moduleURL: string | URL, options?: WorkletOptions): Promise<void>;
23130 declare var Worklet: {
23131 prototype: Worklet;
23133 isInstance: IsInstance<Worklet>;
23136 interface WrapperCachedNonISupportsTestInterface {
23139 declare var WrapperCachedNonISupportsTestInterface: {
23140 prototype: WrapperCachedNonISupportsTestInterface;
23141 new(): WrapperCachedNonISupportsTestInterface;
23142 isInstance: IsInstance<WrapperCachedNonISupportsTestInterface>;
23145 interface WritableStream {
23146 readonly locked: boolean;
23147 abort(reason?: any): Promise<void>;
23148 close(): Promise<void>;
23149 getWriter(): WritableStreamDefaultWriter;
23152 declare var WritableStream: {
23153 prototype: WritableStream;
23154 new(underlyingSink?: any, strategy?: QueuingStrategy): WritableStream;
23155 isInstance: IsInstance<WritableStream>;
23158 interface WritableStreamDefaultController {
23159 readonly signal: AbortSignal;
23160 error(e?: any): void;
23163 declare var WritableStreamDefaultController: {
23164 prototype: WritableStreamDefaultController;
23165 new(): WritableStreamDefaultController;
23166 isInstance: IsInstance<WritableStreamDefaultController>;
23169 interface WritableStreamDefaultWriter {
23170 readonly closed: Promise<undefined>;
23171 readonly desiredSize: number | null;
23172 readonly ready: Promise<undefined>;
23173 abort(reason?: any): Promise<void>;
23174 close(): Promise<void>;
23175 releaseLock(): void;
23176 write(chunk?: any): Promise<void>;
23179 declare var WritableStreamDefaultWriter: {
23180 prototype: WritableStreamDefaultWriter;
23181 new(stream: WritableStream): WritableStreamDefaultWriter;
23182 isInstance: IsInstance<WritableStreamDefaultWriter>;
23185 interface XMLDocument extends Document {
23186 addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23187 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23188 removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: XMLDocument, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23189 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23192 declare var XMLDocument: {
23193 prototype: XMLDocument;
23194 new(): XMLDocument;
23195 isInstance: IsInstance<XMLDocument>;
23198 interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
23199 "readystatechange": Event;
23202 interface XMLHttpRequest extends XMLHttpRequestEventTarget {
23203 readonly channel: MozChannel | null;
23204 readonly errorCode: number;
23205 readonly mozAnon: boolean;
23206 mozBackgroundRequest: boolean;
23207 readonly mozSystem: boolean;
23208 onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
23209 readonly readyState: number;
23210 readonly response: any;
23211 readonly responseText: string | null;
23212 responseType: XMLHttpRequestResponseType;
23213 readonly responseURL: string;
23214 readonly responseXML: Document | null;
23215 readonly status: number;
23216 readonly statusText: string;
23218 readonly upload: XMLHttpRequestUpload;
23219 withCredentials: boolean;
23221 getAllResponseHeaders(): string;
23222 getInterface(iid: any): any;
23223 getResponseHeader(header: string): string | null;
23224 open(method: string, url: string | URL): void;
23225 open(method: string, url: string | URL, async: boolean, user?: string | null, password?: string | null): void;
23226 overrideMimeType(mime: string): void;
23227 send(body?: Document | XMLHttpRequestBodyInit | null): void;
23228 sendInputStream(body: InputStream): void;
23229 setOriginAttributes(originAttributes?: OriginAttributesDictionary): void;
23230 setRequestHeader(header: string, value: string): void;
23231 readonly UNSENT: 0;
23232 readonly OPENED: 1;
23233 readonly HEADERS_RECEIVED: 2;
23234 readonly LOADING: 3;
23236 addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23237 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23238 removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23239 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23242 declare var XMLHttpRequest: {
23243 prototype: XMLHttpRequest;
23244 new(params?: MozXMLHttpRequestParameters): XMLHttpRequest;
23245 new(ignored: string): XMLHttpRequest;
23246 readonly UNSENT: 0;
23247 readonly OPENED: 1;
23248 readonly HEADERS_RECEIVED: 2;
23249 readonly LOADING: 3;
23251 isInstance: IsInstance<XMLHttpRequest>;
23254 interface XMLHttpRequestEventTargetEventMap {
23259 "loadstart": Event;
23264 interface XMLHttpRequestEventTarget extends EventTarget {
23265 onabort: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23266 onerror: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23267 onload: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23268 onloadend: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23269 onloadstart: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23270 onprogress: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23271 ontimeout: ((this: XMLHttpRequestEventTarget, ev: Event) => any) | null;
23272 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23273 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23274 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23275 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23278 declare var XMLHttpRequestEventTarget: {
23279 prototype: XMLHttpRequestEventTarget;
23280 new(): XMLHttpRequestEventTarget;
23281 isInstance: IsInstance<XMLHttpRequestEventTarget>;
23284 interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
23285 addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23286 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23287 removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23288 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23291 declare var XMLHttpRequestUpload: {
23292 prototype: XMLHttpRequestUpload;
23293 new(): XMLHttpRequestUpload;
23294 isInstance: IsInstance<XMLHttpRequestUpload>;
23297 interface XMLSerializer {
23298 serializeToStream(root: Node, stream: OutputStream, charset: string | null): void;
23299 serializeToString(root: Node): string;
23302 declare var XMLSerializer: {
23303 prototype: XMLSerializer;
23304 new(): XMLSerializer;
23305 isInstance: IsInstance<XMLSerializer>;
23308 interface XPathEvaluator extends XPathEvaluatorMixin {
23311 declare var XPathEvaluator: {
23312 prototype: XPathEvaluator;
23313 new(): XPathEvaluator;
23314 isInstance: IsInstance<XPathEvaluator>;
23317 interface XPathEvaluatorMixin {
23318 createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression;
23319 createNSResolver(nodeResolver: Node): Node;
23320 evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: any): XPathResult;
23323 interface XPathExpression {
23324 evaluate(contextNode: Node, type?: number, result?: any): XPathResult;
23325 evaluateWithContext(contextNode: Node, contextPosition: number, contextSize: number, type?: number, result?: any): XPathResult;
23328 declare var XPathExpression: {
23329 prototype: XPathExpression;
23330 new(): XPathExpression;
23331 isInstance: IsInstance<XPathExpression>;
23334 interface XPathResult {
23335 readonly booleanValue: boolean;
23336 readonly invalidIteratorState: boolean;
23337 readonly numberValue: number;
23338 readonly resultType: number;
23339 readonly singleNodeValue: Node | null;
23340 readonly snapshotLength: number;
23341 readonly stringValue: string;
23342 iterateNext(): Node | null;
23343 snapshotItem(index: number): Node | null;
23344 readonly ANY_TYPE: 0;
23345 readonly NUMBER_TYPE: 1;
23346 readonly STRING_TYPE: 2;
23347 readonly BOOLEAN_TYPE: 3;
23348 readonly UNORDERED_NODE_ITERATOR_TYPE: 4;
23349 readonly ORDERED_NODE_ITERATOR_TYPE: 5;
23350 readonly UNORDERED_NODE_SNAPSHOT_TYPE: 6;
23351 readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
23352 readonly ANY_UNORDERED_NODE_TYPE: 8;
23353 readonly FIRST_ORDERED_NODE_TYPE: 9;
23356 declare var XPathResult: {
23357 prototype: XPathResult;
23358 new(): XPathResult;
23359 readonly ANY_TYPE: 0;
23360 readonly NUMBER_TYPE: 1;
23361 readonly STRING_TYPE: 2;
23362 readonly BOOLEAN_TYPE: 3;
23363 readonly UNORDERED_NODE_ITERATOR_TYPE: 4;
23364 readonly ORDERED_NODE_ITERATOR_TYPE: 5;
23365 readonly UNORDERED_NODE_SNAPSHOT_TYPE: 6;
23366 readonly ORDERED_NODE_SNAPSHOT_TYPE: 7;
23367 readonly ANY_UNORDERED_NODE_TYPE: 8;
23368 readonly FIRST_ORDERED_NODE_TYPE: 9;
23369 isInstance: IsInstance<XPathResult>;
23372 /** Available only in secure contexts. */
23373 interface XRBoundedReferenceSpace extends XRReferenceSpace {
23374 readonly boundsGeometry: DOMPointReadOnly[];
23375 addEventListener<K extends keyof XRReferenceSpaceEventMap>(type: K, listener: (this: XRBoundedReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23376 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23377 removeEventListener<K extends keyof XRReferenceSpaceEventMap>(type: K, listener: (this: XRBoundedReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23378 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23381 declare var XRBoundedReferenceSpace: {
23382 prototype: XRBoundedReferenceSpace;
23383 new(): XRBoundedReferenceSpace;
23384 isInstance: IsInstance<XRBoundedReferenceSpace>;
23387 /** Available only in secure contexts. */
23388 interface XRFrame {
23389 readonly session: XRSession;
23390 getPose(space: XRSpace, baseSpace: XRSpace): XRPose | null;
23391 getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | null;
23394 declare var XRFrame: {
23395 prototype: XRFrame;
23397 isInstance: IsInstance<XRFrame>;
23400 /** Available only in secure contexts. */
23401 interface XRInputSource {
23402 readonly gamepad: Gamepad | null;
23403 readonly gripSpace: XRSpace | null;
23404 readonly handedness: XRHandedness;
23405 readonly profiles: string[];
23406 readonly targetRayMode: XRTargetRayMode;
23407 readonly targetRaySpace: XRSpace;
23410 declare var XRInputSource: {
23411 prototype: XRInputSource;
23412 new(): XRInputSource;
23413 isInstance: IsInstance<XRInputSource>;
23416 /** Available only in secure contexts. */
23417 interface XRInputSourceArray {
23418 readonly length: number;
23419 forEach(callbackfn: (value: XRInputSource, key: number, parent: XRInputSourceArray) => void, thisArg?: any): void;
23420 [index: number]: XRInputSource;
23423 declare var XRInputSourceArray: {
23424 prototype: XRInputSourceArray;
23425 new(): XRInputSourceArray;
23426 isInstance: IsInstance<XRInputSourceArray>;
23429 /** Available only in secure contexts. */
23430 interface XRInputSourceEvent extends Event {
23431 readonly frame: XRFrame;
23432 readonly inputSource: XRInputSource;
23435 declare var XRInputSourceEvent: {
23436 prototype: XRInputSourceEvent;
23437 new(type: string, eventInitDict: XRInputSourceEventInit): XRInputSourceEvent;
23438 isInstance: IsInstance<XRInputSourceEvent>;
23441 /** Available only in secure contexts. */
23442 interface XRInputSourcesChangeEvent extends Event {
23443 readonly added: XRInputSource[];
23444 readonly removed: XRInputSource[];
23445 readonly session: XRSession;
23448 declare var XRInputSourcesChangeEvent: {
23449 prototype: XRInputSourcesChangeEvent;
23450 new(type: string, eventInitDict: XRInputSourcesChangeEventInit): XRInputSourcesChangeEvent;
23451 isInstance: IsInstance<XRInputSourcesChangeEvent>;
23454 /** Available only in secure contexts. */
23456 readonly emulatedPosition: boolean;
23457 readonly transform: XRRigidTransform;
23460 declare var XRPose: {
23463 isInstance: IsInstance<XRPose>;
23466 interface XRReferenceSpaceEventMap {
23470 /** Available only in secure contexts. */
23471 interface XRReferenceSpace extends XRSpace {
23472 onreset: ((this: XRReferenceSpace, ev: Event) => any) | null;
23473 getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
23474 addEventListener<K extends keyof XRReferenceSpaceEventMap>(type: K, listener: (this: XRReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23475 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23476 removeEventListener<K extends keyof XRReferenceSpaceEventMap>(type: K, listener: (this: XRReferenceSpace, ev: XRReferenceSpaceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23477 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23480 declare var XRReferenceSpace: {
23481 prototype: XRReferenceSpace;
23482 new(): XRReferenceSpace;
23483 isInstance: IsInstance<XRReferenceSpace>;
23486 /** Available only in secure contexts. */
23487 interface XRReferenceSpaceEvent extends Event {
23488 readonly referenceSpace: XRReferenceSpace;
23489 readonly transform: XRRigidTransform | null;
23492 declare var XRReferenceSpaceEvent: {
23493 prototype: XRReferenceSpaceEvent;
23494 new(type: string, eventInitDict: XRReferenceSpaceEventInit): XRReferenceSpaceEvent;
23495 isInstance: IsInstance<XRReferenceSpaceEvent>;
23498 /** Available only in secure contexts. */
23499 interface XRRenderState {
23500 readonly baseLayer: XRWebGLLayer | null;
23501 readonly depthFar: number;
23502 readonly depthNear: number;
23503 readonly inlineVerticalFieldOfView: number | null;
23506 declare var XRRenderState: {
23507 prototype: XRRenderState;
23508 new(): XRRenderState;
23509 isInstance: IsInstance<XRRenderState>;
23512 /** Available only in secure contexts. */
23513 interface XRRigidTransform {
23514 readonly inverse: XRRigidTransform;
23515 readonly matrix: Float32Array;
23516 readonly orientation: DOMPointReadOnly;
23517 readonly position: DOMPointReadOnly;
23520 declare var XRRigidTransform: {
23521 prototype: XRRigidTransform;
23522 new(position?: DOMPointInit, orientation?: DOMPointInit): XRRigidTransform;
23523 isInstance: IsInstance<XRRigidTransform>;
23526 interface XRSessionEventMap {
23528 "inputsourceschange": Event;
23530 "selectend": Event;
23531 "selectstart": Event;
23533 "squeezeend": Event;
23534 "squeezestart": Event;
23535 "visibilitychange": Event;
23538 /** Available only in secure contexts. */
23539 interface XRSession extends EventTarget {
23540 readonly frameRate: number | null;
23541 readonly inputSources: XRInputSourceArray;
23542 onend: ((this: XRSession, ev: Event) => any) | null;
23543 oninputsourceschange: ((this: XRSession, ev: Event) => any) | null;
23544 onselect: ((this: XRSession, ev: Event) => any) | null;
23545 onselectend: ((this: XRSession, ev: Event) => any) | null;
23546 onselectstart: ((this: XRSession, ev: Event) => any) | null;
23547 onsqueeze: ((this: XRSession, ev: Event) => any) | null;
23548 onsqueezeend: ((this: XRSession, ev: Event) => any) | null;
23549 onsqueezestart: ((this: XRSession, ev: Event) => any) | null;
23550 onvisibilitychange: ((this: XRSession, ev: Event) => any) | null;
23551 readonly renderState: XRRenderState;
23552 readonly supportedFrameRates: Float32Array | null;
23553 readonly visibilityState: XRVisibilityState;
23554 cancelAnimationFrame(handle: number): void;
23555 end(): Promise<void>;
23556 requestAnimationFrame(callback: XRFrameRequestCallback): number;
23557 requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
23558 updateRenderState(state?: XRRenderStateInit): void;
23559 updateTargetFrameRate(rate: number): Promise<void>;
23560 addEventListener<K extends keyof XRSessionEventMap>(type: K, listener: (this: XRSession, ev: XRSessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23561 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23562 removeEventListener<K extends keyof XRSessionEventMap>(type: K, listener: (this: XRSession, ev: XRSessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23563 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23566 declare var XRSession: {
23567 prototype: XRSession;
23569 isInstance: IsInstance<XRSession>;
23572 /** Available only in secure contexts. */
23573 interface XRSessionEvent extends Event {
23574 readonly session: XRSession;
23577 declare var XRSessionEvent: {
23578 prototype: XRSessionEvent;
23579 new(type: string, eventInitDict: XRSessionEventInit): XRSessionEvent;
23580 isInstance: IsInstance<XRSessionEvent>;
23583 /** Available only in secure contexts. */
23584 interface XRSpace extends EventTarget {
23587 declare var XRSpace: {
23588 prototype: XRSpace;
23590 isInstance: IsInstance<XRSpace>;
23593 interface XRSystemEventMap {
23594 "devicechange": Event;
23597 /** Available only in secure contexts. */
23598 interface XRSystem extends EventTarget {
23599 ondevicechange: ((this: XRSystem, ev: Event) => any) | null;
23600 isSessionSupported(mode: XRSessionMode): Promise<boolean>;
23601 requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
23602 addEventListener<K extends keyof XRSystemEventMap>(type: K, listener: (this: XRSystem, ev: XRSystemEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23603 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23604 removeEventListener<K extends keyof XRSystemEventMap>(type: K, listener: (this: XRSystem, ev: XRSystemEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23605 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23608 declare var XRSystem: {
23609 prototype: XRSystem;
23611 isInstance: IsInstance<XRSystem>;
23614 /** Available only in secure contexts. */
23616 readonly eye: XREye;
23617 readonly projectionMatrix: Float32Array;
23618 readonly transform: XRRigidTransform;
23621 declare var XRView: {
23624 isInstance: IsInstance<XRView>;
23627 /** Available only in secure contexts. */
23628 interface XRViewerPose extends XRPose {
23629 readonly views: XRView[];
23632 declare var XRViewerPose: {
23633 prototype: XRViewerPose;
23634 new(): XRViewerPose;
23635 isInstance: IsInstance<XRViewerPose>;
23638 /** Available only in secure contexts. */
23639 interface XRViewport {
23640 readonly height: number;
23641 readonly width: number;
23642 readonly x: number;
23643 readonly y: number;
23646 declare var XRViewport: {
23647 prototype: XRViewport;
23649 isInstance: IsInstance<XRViewport>;
23652 /** Available only in secure contexts. */
23653 interface XRWebGLLayer {
23654 readonly antialias: boolean;
23655 readonly framebuffer: WebGLFramebuffer | null;
23656 readonly framebufferHeight: number;
23657 readonly framebufferWidth: number;
23658 readonly ignoreDepthValues: boolean;
23659 getViewport(view: XRView): XRViewport | null;
23662 declare var XRWebGLLayer: {
23663 prototype: XRWebGLLayer;
23664 new(session: XRSession, context: XRWebGLRenderingContext, layerInit?: XRWebGLLayerInit): XRWebGLLayer;
23665 isInstance: IsInstance<XRWebGLLayer>;
23666 getNativeFramebufferScaleFactor(session: XRSession): number;
23669 interface XSLTProcessor {
23671 clearParameters(): void;
23672 getParameter(namespaceURI: string | null, localName: string): XSLTParameterValue | null;
23673 importStylesheet(style: Node): void;
23674 removeParameter(namespaceURI: string | null, localName: string): void;
23676 setParameter(namespaceURI: string | null, localName: string, value: XSLTParameterValue): void;
23677 transformToDocument(source: Node): Document;
23678 transformToFragment(source: Node, output: Document): DocumentFragment;
23679 readonly DISABLE_ALL_LOADS: 1;
23682 declare var XSLTProcessor: {
23683 prototype: XSLTProcessor;
23684 new(): XSLTProcessor;
23685 readonly DISABLE_ALL_LOADS: 1;
23686 isInstance: IsInstance<XSLTProcessor>;
23689 interface XULCommandDispatcher {
23692 interface XULCommandEvent extends UIEvent {
23693 readonly altKey: boolean;
23694 readonly button: number;
23695 readonly ctrlKey: boolean;
23696 readonly inputSource: number;
23697 readonly metaKey: boolean;
23698 readonly shiftKey: boolean;
23699 readonly sourceEvent: Event | null;
23700 initCommandEvent(type: string, canBubble?: boolean, cancelable?: boolean, view?: Window | null, detail?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean, buttonArg?: number, sourceEvent?: Event | null, inputSource?: number): void;
23703 declare var XULCommandEvent: {
23704 prototype: XULCommandEvent;
23705 new(): XULCommandEvent;
23706 isInstance: IsInstance<XULCommandEvent>;
23709 interface XULControllers {
23712 interface XULElementEventMap extends ElementEventMap, GlobalEventHandlersEventMap, OnErrorEventHandlerForNodesEventMap, TouchEventHandlersEventMap {
23715 interface XULElement extends Element, ElementCSSInlineStyle, GlobalEventHandlers, HTMLOrForeignElement, OnErrorEventHandlerForNodes, TouchEventHandlers {
23716 collapsed: boolean;
23717 contextMenu: string;
23718 readonly controllers: XULControllers;
23724 tooltipText: string;
23727 hasMenu(): boolean;
23728 openMenu(open: boolean): void;
23729 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23730 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23731 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23732 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23735 declare var XULElement: {
23736 prototype: XULElement;
23738 isInstance: IsInstance<XULElement>;
23741 interface XULFrameElement extends XULElement, MozFrameLoaderOwner {
23742 readonly browserId: number;
23743 readonly contentDocument: Document | null;
23744 readonly contentWindow: WindowProxy | null;
23745 readonly docShell: nsIDocShell | null;
23746 openWindowInfo: nsIOpenWindowInfo | null;
23747 readonly webNavigation: nsIWebNavigation | null;
23748 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULFrameElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23749 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23750 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULFrameElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23751 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23754 declare var XULFrameElement: {
23755 prototype: XULFrameElement;
23756 new(): XULFrameElement;
23757 isInstance: IsInstance<XULFrameElement>;
23760 interface XULMenuElement extends XULElement {
23761 activeChild: Element | null;
23762 readonly openedWithKey: boolean;
23763 handleKeyPress(keyEvent: KeyboardEvent): boolean;
23764 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULMenuElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23765 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23766 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULMenuElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23767 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23770 declare var XULMenuElement: {
23771 prototype: XULMenuElement;
23772 new(): XULMenuElement;
23773 isInstance: IsInstance<XULMenuElement>;
23776 interface XULPopupElement extends XULElement {
23777 readonly anchorNode: Element | null;
23778 readonly isWaylandDragSource: boolean;
23779 readonly isWaylandPopup: boolean;
23782 readonly state: string;
23783 readonly triggerNode: Node | null;
23784 activateItem(itemElement: Element, options?: ActivateMenuItemOptions): void;
23785 getOuterScreenRect(): DOMRect;
23786 hidePopup(cancel?: boolean): void;
23787 moveTo(left: number, top: number): void;
23788 moveToAnchor(anchorElement?: Element | null, position?: string, x?: number, y?: number, attributesOverride?: boolean): void;
23789 openPopup(anchorElement?: Element | null, options?: StringOrOpenPopupOptions, x?: number, y?: number, isContextMenu?: boolean, attributesOverride?: boolean, triggerEvent?: Event | null): void;
23790 openPopupAtScreen(x?: number, y?: number, isContextMenu?: boolean, triggerEvent?: Event | null): void;
23791 openPopupAtScreenRect(position?: string, x?: number, y?: number, width?: number, height?: number, isContextMenu?: boolean, attributesOverride?: boolean, triggerEvent?: Event | null): void;
23792 setConstraintRect(rect: DOMRectReadOnly): void;
23793 sizeTo(width: number, height: number): void;
23794 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULPopupElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23795 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23796 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULPopupElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23797 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23800 declare var XULPopupElement: {
23801 prototype: XULPopupElement;
23802 new(): XULPopupElement;
23803 isInstance: IsInstance<XULPopupElement>;
23806 interface XULResizerElement extends XULElement {
23807 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULResizerElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23808 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23809 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULResizerElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23810 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23813 declare var XULResizerElement: {
23814 prototype: XULResizerElement;
23815 new(): XULResizerElement;
23816 isInstance: IsInstance<XULResizerElement>;
23819 interface XULTextElement extends XULElement {
23823 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULTextElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23824 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23825 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULTextElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23826 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23829 declare var XULTextElement: {
23830 prototype: XULTextElement;
23831 new(): XULTextElement;
23832 isInstance: IsInstance<XULTextElement>;
23835 interface XULTreeElement extends XULElement {
23836 readonly columns: TreeColumns | null;
23838 readonly horizontalPosition: number;
23839 readonly rowHeight: number;
23840 readonly rowWidth: number;
23841 readonly treeBody: Element | null;
23842 view: MozTreeView | null;
23843 beginUpdateBatch(): void;
23844 clearStyleAndImageCaches(): void;
23845 endUpdateBatch(): void;
23846 ensureCellIsVisible(row: number, col: TreeColumn | null): void;
23847 ensureRowIsVisible(index: number): void;
23848 getCellAt(x: number, y: number): TreeCellInfo;
23849 getCoordsForCellItem(row: number, col: TreeColumn, element: string): DOMRect | null;
23850 getFirstVisibleRow(): number;
23851 getLastVisibleRow(): number;
23852 getPageLength(): number;
23853 getRowAt(x: number, y: number): number;
23854 invalidate(): void;
23855 invalidateCell(row: number, col: TreeColumn | null): void;
23856 invalidateColumn(col: TreeColumn | null): void;
23857 invalidateRange(startIndex: number, endIndex: number): void;
23858 invalidateRow(index: number): void;
23859 isCellCropped(row: number, col: TreeColumn | null): boolean;
23860 removeImageCacheEntry(row: number, col: TreeColumn): void;
23861 rowCountChanged(index: number, count: number): void;
23862 scrollByLines(numLines: number): void;
23863 scrollByPages(numPages: number): void;
23864 scrollToRow(index: number): void;
23865 addEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULTreeElement, ev: XULElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
23866 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
23867 removeEventListener<K extends keyof XULElementEventMap>(type: K, listener: (this: XULTreeElement, ev: XULElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
23868 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
23871 declare var XULTreeElement: {
23872 prototype: XULTreeElement;
23873 new(): XULTreeElement;
23874 isInstance: IsInstance<XULTreeElement>;
23877 interface imgINotificationObserver {
23880 interface imgIRequest {
23883 interface nsIBrowserDOMWindow {
23886 interface nsICookieJarSettings {
23889 interface nsIDOMProcessChild {
23892 interface nsIDOMProcessParent {
23895 interface nsIDOMWindowUtils {
23898 interface nsIDocShell {
23901 interface nsIEditor {
23904 interface nsIEventTarget {
23907 interface nsIFile {
23910 interface nsIGleanPing {
23913 interface nsILoadGroup {
23916 interface nsIMediaDevice {
23919 interface nsIOpenWindowInfo {
23922 interface nsIPermissionDelegateHandler {
23925 interface nsIPrintSettings {
23928 interface nsIReferrerInfo {
23931 interface nsISHEntry {
23934 interface nsISHistory {
23937 interface nsIScreen {
23940 interface nsISecureBrowserUI {
23943 interface nsISelectionListener {
23946 interface nsISessionStoreRestoreData {
23949 interface nsISocketTransport {
23952 interface nsIStreamListener {
23955 interface nsISupports {
23958 interface nsITransportProvider {
23961 interface nsITreeSelection {
23964 interface nsIWebBrowserPersistDocumentReceiver {
23967 interface nsIWebNavigation {
23970 interface nsIWebProgress {
23973 interface nsIWebProgressListener {
23976 declare namespace AddonManagerPermissions {
23977 function isHostPermitted(host: string): boolean;
23980 declare namespace APZHitResultFlags {
23983 interface Console {
23984 assert(condition?: boolean, ...data: any[]): void;
23986 count(label?: string): void;
23987 countReset(label?: string): void;
23988 createInstance(options?: ConsoleInstanceOptions): ConsoleInstance;
23989 debug(...data: any[]): void;
23990 dir(...data: any[]): void;
23991 dirxml(...data: any[]): void;
23992 error(...data: any[]): void;
23993 exception(...data: any[]): void;
23994 group(...data: any[]): void;
23995 groupCollapsed(...data: any[]): void;
23997 info(...data: any[]): void;
23998 log(...data: any[]): void;
23999 profile(...data: any[]): void;
24000 profileEnd(...data: any[]): void;
24001 table(...data: any[]): void;
24002 time(label?: string): void;
24003 timeEnd(label?: string): void;
24004 timeLog(label?: string, ...data: any[]): void;
24005 timeStamp(data?: any): void;
24006 trace(...data: any[]): void;
24007 warn(...data: any[]): void;
24010 declare var console: Console;
24012 declare namespace CSS {
24013 var highlights: HighlightRegistry;
24014 function escape(ident: string): string;
24015 function registerProperty(definition: PropertyDefinition): void;
24016 function supports(property: string, value: string): boolean;
24017 function supports(conditionText: string): boolean;
24020 declare namespace FuzzingFunctions {
24021 function crash(reason?: string): void;
24022 function cycleCollect(): void;
24023 function enableAccessibility(): void;
24024 function garbageCollect(): void;
24025 function garbageCollectCompacting(): void;
24026 function memoryPressure(): void;
24027 function signalIPCReady(): void;
24028 function synthesizeKeyboardEvents(aKeyValue: string, aDictionary?: KeyboardEventInit): void;
24031 declare namespace TestUtils {
24032 function gc(): Promise<void>;
24035 declare namespace WebrtcGlobalInformation {
24036 var aecDebug: boolean;
24037 var aecDebugLogDir: string;
24038 function clearAllStats(): void;
24039 function clearLogging(): void;
24040 function getAllStats(callback: WebrtcGlobalStatisticsCallback, pcIdFilter?: string): void;
24041 function getLogging(pattern: string, callback: WebrtcGlobalLoggingCallback): void;
24042 function getMediaContext(): WebrtcGlobalMediaContext;
24043 function getStatsHistoryPcIds(callback: WebrtcGlobalStatisticsHistoryPcIdsCallback): void;
24044 function getStatsHistorySince(callback: WebrtcGlobalStatisticsHistoryCallback, pcIdFilter: string, after?: DOMHighResTimeStamp, sdpAfter?: DOMHighResTimeStamp): void;
24047 declare namespace ChromeUtils {
24048 var aliveUtilityProcesses: number;
24049 var domProcessChild: nsIDOMProcessChild | null;
24050 var recentJSDevError: any;
24051 function CreateOriginAttributesFromOriginSuffix(suffix: string): OriginAttributesDictionary;
24052 function addProfilerMarker(name: string, options?: ProfilerMarkerOptions | DOMHighResTimeStamp, text?: string): void;
24053 function base64URLDecode(string: string, options: Base64URLDecodeOptions): ArrayBuffer;
24054 function base64URLEncode(source: BufferSource, options: Base64URLEncodeOptions): string;
24055 function clearRecentJSDevError(): void;
24056 function clearStyleSheetCache(): void;
24057 function clearStyleSheetCacheByBaseDomain(baseDomain: string): void;
24058 function clearStyleSheetCacheByPrincipal(principal: Principal): void;
24059 function collectPerfStats(): Promise<string>;
24060 function collectScrollingData(): Promise<InteractionData>;
24061 function compileScript(url: string, options?: CompileScriptOptionsDictionary): Promise<PrecompiledScript>;
24062 function consumeInteractionData(): Record<string, InteractionData>;
24063 function createError(message: string, stack?: any): any;
24064 function createOriginAttributesFromOrigin(origin: string): OriginAttributesDictionary;
24065 function dateNow(): number;
24066 function defineESModuleGetters(aTarget: any, aModules: any, aOptions?: ImportESModuleOptionsDictionary): void;
24067 function defineLazyGetter(aTarget: any, aName: any, aLambda: any): void;
24068 function defineModuleGetter(target: any, id: string, resourceURI: string): void;
24069 function endWheelTransaction(): void;
24070 function ensureJSOracleStarted(): void;
24071 function fillNonDefaultOriginAttributes(originAttrs?: OriginAttributesDictionary): OriginAttributesDictionary;
24072 function generateQI(interfaces: any[]): MozQueryInterface;
24073 function getAllDOMProcesses(): nsIDOMProcessParent[];
24074 function getAllPossibleUtilityActorNames(): string[];
24075 function getBaseDomainFromPartitionKey(partitionKey: string): string;
24076 function getCallerLocation(principal: Principal): any;
24077 function getClassName(obj: any, unwrap?: boolean): string;
24078 function getFormAutofillConfidences(elements: Element[]): FormAutofillConfidences[];
24079 function getGMPContentDecryptionModuleInformation(): Promise<CDMInformation[]>;
24080 function getLibcConstants(): LibcConstants;
24081 function getObjectNodeId(obj: any): NodeId;
24082 function getPartitionKeyFromURL(url: string): string;
24083 function getPopupControlState(): PopupBlockerState;
24084 function getWMFContentDecryptionModuleInformation(): Promise<CDMInformation[]>;
24085 function getXPCOMErrorName(aErrorCode: number): string;
24086 function hasReportingHeaderForOrigin(aOrigin: string): boolean;
24087 function idleDispatch(callback: IdleRequestCallback, options?: IdleRequestOptions): void;
24088 function import_(aResourceURI: string, aTargetObj?: any): any;
24089 function importESModule(aResourceURI: string, aOptions?: ImportESModuleOptionsDictionary): any;
24090 function isClassifierBlockingErrorCode(aError: number): boolean;
24091 function isDOMObject(obj: any, unwrap?: boolean): boolean;
24092 function isDarkBackground(element: Element): boolean;
24093 function isDevToolsOpened(): boolean;
24094 function isISOStyleDate(str: string): boolean;
24095 function isOriginAttributesEqual(aA?: OriginAttributesDictionary, aB?: OriginAttributesDictionary): boolean;
24096 function lastExternalProtocolIframeAllowed(): number;
24097 function nondeterministicGetWeakMapKeys(map: any): any;
24098 function nondeterministicGetWeakSetKeys(aSet: any): any;
24099 function notifyDevToolsClosed(): void;
24100 function notifyDevToolsOpened(): void;
24101 function originAttributesMatchPattern(originAttrs?: OriginAttributesDictionary, pattern?: OriginAttributesPatternDictionary): boolean;
24102 function originAttributesToSuffix(originAttrs?: OriginAttributesDictionary): string;
24103 function privateNoteIntentionalCrash(): void;
24104 function readHeapSnapshot(filePath: string): HeapSnapshot;
24105 function registerProcessActor(aName: string, aOptions?: ProcessActorOptions): void;
24106 function registerWindowActor(aName: string, aOptions?: WindowActorOptions): void;
24107 function releaseAssert(condition: boolean, message?: string): void;
24108 function requestProcInfo(): Promise<ParentProcInfoDictionary>;
24109 function resetLastExternalProtocolIframeAllowed(): void;
24110 function saveHeapSnapshot(boundaries?: HeapSnapshotBoundaries): string;
24111 function saveHeapSnapshotGetId(boundaries?: HeapSnapshotBoundaries): string;
24112 function setPerfStatsCollectionMask(aCollectionMask: number): void;
24113 function shallowClone(obj: any, target?: any): any;
24114 function shouldResistFingerprinting(target: JSRFPTarget, overriddenFingerprintingSettings: number | null): boolean;
24115 function unregisterProcessActor(aName: string): void;
24116 function unregisterWindowActor(aName: string): void;
24117 function unwaiveXrays(val: any): any;
24118 function vsyncEnabled(): boolean;
24119 function waiveXrays(val: any): any;
24122 declare namespace InspectorUtils {
24123 function addPseudoClassLock(element: Element, pseudoClass: string, enabled?: boolean): void;
24124 function clearPseudoClassLocks(element: Element): void;
24125 function colorTo(fromColor: string, toColorSpace: string): InspectorColorToResult | null;
24126 function colorToRGBA(colorString: string, doc?: Document | null): InspectorRGBATuple | null;
24127 function containingBlockOf(element: Element): Element | null;
24128 function cssPropertyIsShorthand(property: string): boolean;
24129 function cssPropertySupportsType(property: string, type: InspectorPropertyType): boolean;
24130 function getAllStyleSheets(document: Document, documentOnly?: boolean): StyleSheet[];
24131 function getBlockLineCounts(element: Element): number[] | null;
24132 function getCSSPropertyNames(options?: PropertyNamesOptions): string[];
24133 function getCSSPropertyPrefs(): PropertyPref[];
24134 function getCSSPseudoElementNames(): string[];
24135 function getCSSRegisteredProperties(document: Document): InspectorCSSPropertyDefinition[];
24136 function getCSSStyleRules(element: Element, pseudo?: string, relevantLinkVisited?: boolean, withStartingStyle?: boolean): CSSStyleRule[];
24137 function getCSSValuesForProperty(property: string): string[];
24138 function getChildrenForNode(node: Node, showingAnonymousContent: boolean, includeAssignedNodes: boolean): Node[];
24139 function getContentState(element: Element): number;
24140 function getOverflowingChildrenOfElement(element: Element): NodeList;
24141 function getParentForNode(node: Node, showingAnonymousContent: boolean): Node | null;
24142 function getRegisteredCssHighlights(document: Document, activeOnly?: boolean): string[];
24143 function getRelativeRuleLine(rule: CSSRule): number;
24144 function getRuleBodyText(initialText: string): string | null;
24145 function getRuleColumn(rule: CSSRule): number;
24146 function getRuleIndex(rule: CSSRule): number[];
24147 function getRuleLine(rule: CSSRule): number;
24148 function getStyleSheetRuleCountAndAtRules(sheet: CSSStyleSheet): InspectorStyleSheetRuleCountAndAtRulesResult;
24149 function getSubpropertiesForCSSProperty(property: string): string[];
24150 function getUsedFontFaces(range: Range, maxRanges?: number, skipCollapsedWhitespace?: boolean): InspectorFontFace[];
24151 function hasPseudoClassLock(element: Element, pseudoClass: string): boolean;
24152 function hasRulesModifiedByCSSOM(sheet: CSSStyleSheet): boolean;
24153 function isCustomElementName(name: string | null, namespaceURI: string | null): boolean;
24154 function isElementThemed(element: Element): boolean;
24155 function isIgnorableWhitespace(dataNode: CharacterData): boolean;
24156 function isInheritedProperty(document: Document, property: string): boolean;
24157 function isUsedColorSchemeDark(element: Element): boolean;
24158 function isValidCSSColor(colorString: string): boolean;
24159 function parseStyleSheet(sheet: CSSStyleSheet, input: string): void;
24160 function removeContentState(element: Element, state: number, clearActiveDocument?: boolean): boolean;
24161 function removePseudoClassLock(element: Element, pseudoClass: string): void;
24162 function replaceBlockRuleBodyTextInStylesheet(styleSheetText: string, line: number, column: number, newBodyText: string): string | null;
24163 function rgbToColorName(r: number, g: number, b: number): string;
24164 function setContentState(element: Element, state: number): boolean;
24165 function supports(conditionText: string, options?: SupportsOptions): boolean;
24166 function valueMatchesSyntax(document: Document, value: string, syntax: string): boolean;
24169 declare namespace IOUtils {
24170 var profileBeforeChange: any;
24171 var sendTelemetry: any;
24172 function computeHexDigest(path: string, method: HashAlgorithm): Promise<string>;
24173 function copy(sourcePath: string, destPath: string, options?: CopyOptions): Promise<void>;
24174 function createUniqueDirectory(parent: string, prefix: string, permissions?: number): Promise<string>;
24175 function createUniqueFile(parent: string, prefix: string, permissions?: number): Promise<string>;
24176 function delMacXAttr(path: string, attr: string): Promise<void>;
24177 function exists(path: string): Promise<boolean>;
24178 function getChildren(path: string, options?: GetChildrenOptions): Promise<string[]>;
24179 function getDirectory(...components: string[]): Promise<nsIFile>;
24180 function getFile(...components: string[]): Promise<nsIFile>;
24181 function getMacXAttr(path: string, attr: string): Promise<Uint8Array>;
24182 function getWindowsAttributes(path: string): Promise<WindowsFileAttributes>;
24183 function hasMacXAttr(path: string, attr: string): Promise<boolean>;
24184 function makeDirectory(path: string, options?: MakeDirectoryOptions): Promise<void>;
24185 function move(sourcePath: string, destPath: string, options?: MoveOptions): Promise<void>;
24186 function read(path: string, opts?: ReadOptions): Promise<Uint8Array>;
24187 function readJSON(path: string, opts?: ReadUTF8Options): Promise<any>;
24188 function readUTF8(path: string, opts?: ReadUTF8Options): Promise<string>;
24189 function remove(path: string, options?: RemoveOptions): Promise<void>;
24190 function setAccessTime(path: string, access?: number): Promise<number>;
24191 function setMacXAttr(path: string, attr: string, value: Uint8Array): Promise<void>;
24192 function setModificationTime(path: string, modification?: number): Promise<number>;
24193 function setPermissions(path: string, permissions: number, honorUmask?: boolean): Promise<void>;
24194 function setWindowsAttributes(path: string, attrs?: WindowsFileAttributes): Promise<void>;
24195 function stat(path: string): Promise<FileInfo>;
24196 function write(path: string, data: Uint8Array, options?: WriteOptions): Promise<number>;
24197 function writeJSON(path: string, value: any, options?: WriteOptions): Promise<number>;
24198 function writeUTF8(path: string, string: string, options?: WriteOptions): Promise<number>;
24201 declare namespace L10nOverlays {
24202 function translateElement(element: Element, translation?: L10nMessage): L10nOverlaysError[] | null;
24205 declare namespace MediaControlService {
24206 function generateMediaControlKey(aKey: MediaControlKey): void;
24207 function getCurrentActiveMediaMetadata(): MediaMetadataInit;
24208 function getCurrentMediaSessionPlaybackState(): MediaSessionPlaybackState;
24211 declare namespace PathUtils {
24212 var localProfileDir: string;
24213 var profileDir: string;
24214 var tempDir: string;
24215 var xulLibraryPath: string;
24216 function filename(path: string): string;
24217 function isAbsolute(path: string): boolean;
24218 function join(...components: string[]): string;
24219 function joinRelative(base: string, relativePath: string): string;
24220 function normalize(path: string): string;
24221 function parent(path: string, depth?: number): string | null;
24222 function split(path: string): string[];
24223 function splitRelative(path: string, options?: SplitRelativeOptions): string[];
24224 function toExtendedWindowsPath(path: string): string;
24225 function toFileURI(path: string): string;
24228 declare namespace PlacesObservers {
24229 var counts: PlacesEventCounts;
24230 function addListener(eventTypes: PlacesEventType[], listener: PlacesEventCallback): void;
24231 function addListener(eventTypes: PlacesEventType[], listener: PlacesWeakCallbackWrapper): void;
24232 function notifyListeners(events: PlacesEvent[]): void;
24233 function removeListener(eventTypes: PlacesEventType[], listener: PlacesEventCallback): void;
24234 function removeListener(eventTypes: PlacesEventType[], listener: PlacesWeakCallbackWrapper): void;
24237 declare namespace PromiseDebugging {
24238 function addUncaughtRejectionObserver(o: UncaughtRejectionObserver): void;
24239 function getAllocationStack(p: any): any;
24240 function getFullfillmentStack(p: any): any;
24241 function getPromiseID(p: any): string;
24242 function getRejectionStack(p: any): any;
24243 function getState(p: any): PromiseDebuggingStateHolder;
24244 function removeUncaughtRejectionObserver(o: UncaughtRejectionObserver): boolean;
24247 declare namespace SessionStoreUtils {
24248 function addDynamicFrameFilteredListener(target: EventTarget, type: string, listener: any, useCapture: boolean, mozSystemGroup?: boolean): nsISupports | null;
24249 function collectDocShellCapabilities(docShell: nsIDocShell): string;
24250 function collectFormData(window: WindowProxy): CollectedData | null;
24251 function collectScrollPosition(window: WindowProxy): CollectedData | null;
24252 function constructSessionStoreRestoreData(): nsISessionStoreRestoreData;
24253 function forEachNonDynamicChildFrame(window: WindowProxy, callback: SessionStoreUtilsFrameCallback): void;
24254 function initializeRestore(browsingContext: CanonicalBrowsingContext, data: nsISessionStoreRestoreData | null): Promise<void>;
24255 function removeDynamicFrameFilteredListener(target: EventTarget, type: string, listener: nsISupports, useCapture: boolean, mozSystemGroup?: boolean): void;
24256 function restoreDocShellCapabilities(docShell: nsIDocShell, disallowCapabilities: string): void;
24257 function restoreDocShellState(browsingContext: CanonicalBrowsingContext, url: string | null, docShellCaps: string | null): Promise<void>;
24258 function restoreFormData(document: Document, data?: CollectedData): boolean;
24259 function restoreScrollPosition(frame: Window, data?: CollectedData): void;
24260 function restoreSessionStorageFromParent(browsingContext: CanonicalBrowsingContext, sessionStorage: Record<string, Record<string, string>>): void;
24263 declare namespace TelemetryStopwatch {
24264 function cancel(histogram: HistogramID, obj?: any): boolean;
24265 function cancelKeyed(histogram: HistogramID, key: HistogramKey, obj?: any): boolean;
24266 function finish(histogram: HistogramID, obj?: any, canceledOkay?: boolean): boolean;
24267 function finishKeyed(histogram: HistogramID, key: HistogramKey, obj?: any, canceledOkay?: boolean): boolean;
24268 function running(histogram: HistogramID, obj?: any): boolean;
24269 function runningKeyed(histogram: HistogramID, key: HistogramKey, obj?: any): boolean;
24270 function setTestModeEnabled(testing?: boolean): void;
24271 function start(histogram: HistogramID, obj?: any, options?: TelemetryStopwatchOptions): boolean;
24272 function startKeyed(histogram: HistogramID, key: HistogramKey, obj?: any, options?: TelemetryStopwatchOptions): boolean;
24273 function timeElapsed(histogram: HistogramID, obj?: any, canceledOkay?: boolean): number;
24274 function timeElapsedKeyed(histogram: HistogramID, key: HistogramKey, obj?: any, canceledOkay?: boolean): number;
24277 declare namespace UniFFIScaffolding {
24278 function callAsync(id: UniFFIFunctionId, ...args: UniFFIScaffoldingValue[]): Promise<UniFFIScaffoldingCallResult>;
24279 function callSync(id: UniFFIFunctionId, ...args: UniFFIScaffoldingValue[]): UniFFIScaffoldingCallResult;
24280 function deregisterCallbackHandler(interfaceId: UniFFICallbackInterfaceId): void;
24281 function readPointer(id: UniFFIPointerId, buff: ArrayBuffer, position: number): UniFFIPointer;
24282 function registerCallbackHandler(interfaceId: UniFFICallbackInterfaceId, handler: UniFFICallbackHandler): void;
24283 function writePointer(id: UniFFIPointerId, ptr: UniFFIPointer, buff: ArrayBuffer, position: number): void;
24286 declare namespace UserInteraction {
24287 function cancel(id: string, obj?: any): boolean;
24288 function finish(id: string, obj?: any, additionalText?: string): boolean;
24289 function running(id: string, obj?: any): boolean;
24290 function start(id: string, value: string, obj?: any): boolean;
24291 function update(id: string, value: string, obj?: any): boolean;
24294 interface AnyCallback {
24298 interface AudioDataOutputCallback {
24299 (output: AudioData): void;
24302 interface BlobCallback {
24303 (blob: Blob | null): void;
24306 interface ChainedOperation {
24310 interface ConsoleInstanceDumpCallback {
24311 (message: string): void;
24314 interface CreateHTMLCallback {
24315 (input: string, ...arguments: any[]): string | null;
24318 interface CreateScriptCallback {
24319 (input: string, ...arguments: any[]): string | null;
24322 interface CreateScriptURLCallback {
24323 (input: string, ...arguments: any[]): string | null;
24326 interface CustomElementConstructor {
24330 interface CustomElementCreationCallback {
24331 (name: string): void;
24334 interface DebuggerNotificationCallback {
24335 (n: DebuggerNotification): void;
24338 interface DecodeErrorCallback {
24339 (error: DOMException): void;
24342 interface DecodeSuccessCallback {
24343 (decodedData: AudioBuffer): void;
24346 interface EncodedAudioChunkOutputCallback {
24347 (output: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void;
24350 interface EncodedVideoChunkOutputCallback {
24351 (chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void;
24354 interface ErrorCallback {
24355 (err: DOMException): void;
24358 interface FileCallback {
24359 (file: File): void;
24362 interface FileSystemEntriesCallback {
24363 (entries: FileSystemEntry[]): void;
24366 interface FileSystemEntryCallback {
24367 (entry: FileSystemEntry): void;
24370 interface FontFaceSetForEachCallback {
24371 (value: FontFace, key: FontFace, set: FontFaceSet): void;
24374 interface FrameRequestCallback {
24375 (time: DOMHighResTimeStamp): void;
24378 interface FunctionStringCallback {
24379 (data: string): void;
24382 interface GenerateAssertionCallback {
24383 (contents: string, origin: string, options: RTCIdentityProviderOptions): RTCIdentityAssertionResult | PromiseLike<RTCIdentityAssertionResult>;
24386 interface IdleRequestCallback {
24387 (deadline: IdleDeadline): void;
24390 interface InstallTriggerCallback {
24391 (url: string, status: number): void;
24394 interface IntersectionCallback {
24395 (entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
24398 interface LockGrantedCallback {
24399 (lock: Lock | null): any;
24402 interface MediaSessionActionHandler {
24403 (details: MediaSessionActionDetails): void;
24406 interface MutationCallback {
24407 (mutations: MutationRecord[], observer: MutationObserver): void;
24410 interface NavigatorUserMediaErrorCallback {
24411 (error: MediaStreamError): void;
24414 interface NavigatorUserMediaSuccessCallback {
24415 (stream: MediaStream): void;
24418 interface NotificationPermissionCallback {
24419 (permission: NotificationPermission): void;
24422 interface OnBeforeUnloadEventHandlerNonNull {
24423 (event: Event): string | null;
24426 interface OnErrorEventHandlerNonNull {
24427 (event: Event | string, source?: string, lineno?: number, column?: number, error?: any): any;
24430 interface PeerConnectionLifecycleCallback {
24431 (pc: RTCPeerConnection, windowId: number, eventType: RTCLifecycleEvent): void;
24434 interface PerformanceObserverCallback {
24435 (entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
24438 interface PlacesEventCallback {
24439 (events: PlacesEvent[]): void;
24442 interface PositionCallback {
24443 (position: GeolocationPosition): void;
24446 interface PositionErrorCallback {
24447 (positionError: GeolocationPositionError): void;
24450 interface PrintCallback {
24451 (ctx: MozCanvasPrintState): void;
24454 interface PromiseDocumentFlushedCallback {
24458 interface PromiseReturner {
24462 interface QueuingStrategySize {
24463 (chunk?: any): number;
24466 interface RTCPeerConnectionErrorCallback {
24467 (error: DOMException): void;
24470 interface RTCSessionDescriptionCallback {
24471 (description: RTCSessionDescriptionInit): void;
24474 interface ReportingObserverCallback {
24475 (reports: Report[], observer: ReportingObserver): void;
24478 interface ResizeObserverCallback {
24479 (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
24482 interface SchedulerPostTaskCallback {
24486 interface SessionStoreUtilsFrameCallback {
24487 (frame: WindowProxy, index: number): void;
24490 interface SetDeleteBooleanCallback {
24491 (value: boolean, index: number): void;
24494 interface SetDeleteInterfaceCallback {
24495 (value: TestInterfaceObservableArray, index: number): void;
24498 interface SetDeleteObjectCallback {
24499 (value: any, index: number): void;
24502 interface TestThrowingCallback {
24506 interface UniFFICallbackHandler {
24507 (objectId: UniFFICallbackObjectHandle, methodId: UniFFICallbackMethodId, aArgs: ArrayBuffer): void;
24510 interface ValidateAssertionCallback {
24511 (assertion: string, origin: string): RTCIdentityValidationResult | PromiseLike<RTCIdentityValidationResult>;
24514 interface VideoFrameOutputCallback {
24515 (output: VideoFrame): void;
24518 interface VoidFunction {
24522 interface WebCodecsErrorCallback {
24523 (error: DOMException): void;
24526 interface WebExtensionLocalizeCallback {
24527 (unlocalizedText: string): string;
24530 interface WebrtcGlobalLoggingCallback {
24531 (logMessages: string[]): void;
24534 interface WebrtcGlobalStatisticsCallback {
24535 (reports: WebrtcGlobalStatisticsReport): void;
24538 interface WebrtcGlobalStatisticsHistoryCallback {
24539 (reports: WebrtcGlobalStatisticsReport): void;
24542 interface WebrtcGlobalStatisticsHistoryPcIdsCallback {
24543 (pcIds: string[]): void;
24546 interface XRFrameRequestCallback {
24547 (time: DOMHighResTimeStamp, frame: XRFrame): void;
24550 interface mozPacketCallback {
24551 (level: number, type: mozPacketDumpType, sending: boolean, packet: ArrayBuffer): void;
24554 interface HTMLElementTagNameMap {
24555 "a": HTMLAnchorElement;
24556 "abbr": HTMLElement;
24557 "acronym": HTMLElement;
24558 "address": HTMLElement;
24559 "applet": HTMLUnknownElement;
24560 "area": HTMLAreaElement;
24561 "article": HTMLElement;
24562 "aside": HTMLElement;
24563 "audio": HTMLAudioElement;
24565 "base": HTMLBaseElement;
24566 "basefont": HTMLElement;
24567 "bdi": HTMLElement;
24568 "bdo": HTMLElement;
24569 "bgsound": HTMLUnknownElement;
24570 "big": HTMLElement;
24571 "blockquote": HTMLQuoteElement;
24572 "body": HTMLBodyElement;
24573 "br": HTMLBRElement;
24574 "button": HTMLButtonElement;
24575 "canvas": HTMLCanvasElement;
24576 "caption": HTMLTableCaptionElement;
24577 "center": HTMLElement;
24578 "cite": HTMLElement;
24579 "code": HTMLElement;
24580 "col": HTMLTableColElement;
24581 "colgroup": HTMLTableColElement;
24582 "data": HTMLDataElement;
24583 "datalist": HTMLDataListElement;
24585 "del": HTMLModElement;
24586 "details": HTMLDetailsElement;
24587 "dfn": HTMLElement;
24588 "dialog": HTMLDialogElement;
24589 "dir": HTMLDirectoryElement;
24590 "div": HTMLDivElement;
24591 "dl": HTMLDListElement;
24594 "embed": HTMLEmbedElement;
24595 "fieldset": HTMLFieldSetElement;
24596 "figcaption": HTMLElement;
24597 "figure": HTMLElement;
24598 "font": HTMLFontElement;
24599 "footer": HTMLElement;
24600 "form": HTMLFormElement;
24601 "frame": HTMLFrameElement;
24602 "frameset": HTMLFrameSetElement;
24603 "h1": HTMLHeadingElement;
24604 "h2": HTMLHeadingElement;
24605 "h3": HTMLHeadingElement;
24606 "h4": HTMLHeadingElement;
24607 "h5": HTMLHeadingElement;
24608 "h6": HTMLHeadingElement;
24609 "head": HTMLHeadElement;
24610 "header": HTMLElement;
24611 "hgroup": HTMLElement;
24612 "hr": HTMLHRElement;
24613 "html": HTMLHtmlElement;
24615 "iframe": HTMLIFrameElement;
24616 "image": HTMLElement;
24617 "img": HTMLImageElement;
24618 "input": HTMLInputElement;
24619 "ins": HTMLModElement;
24620 "kbd": HTMLElement;
24621 "keygen": HTMLUnknownElement;
24622 "label": HTMLLabelElement;
24623 "legend": HTMLLegendElement;
24624 "li": HTMLLIElement;
24625 "link": HTMLLinkElement;
24626 "listing": HTMLPreElement;
24627 "main": HTMLElement;
24628 "map": HTMLMapElement;
24629 "mark": HTMLElement;
24630 "marquee": HTMLMarqueeElement;
24631 "menu": HTMLMenuElement;
24632 "meta": HTMLMetaElement;
24633 "meter": HTMLMeterElement;
24634 "multicol": HTMLUnknownElement;
24635 "nav": HTMLElement;
24636 "nobr": HTMLElement;
24637 "noembed": HTMLElement;
24638 "noframes": HTMLElement;
24639 "noscript": HTMLElement;
24640 "object": HTMLObjectElement;
24641 "ol": HTMLOListElement;
24642 "optgroup": HTMLOptGroupElement;
24643 "option": HTMLOptionElement;
24644 "output": HTMLOutputElement;
24645 "p": HTMLParagraphElement;
24646 "param": HTMLParamElement;
24647 "picture": HTMLPictureElement;
24648 "plaintext": HTMLElement;
24649 "pre": HTMLPreElement;
24650 "progress": HTMLProgressElement;
24651 "q": HTMLQuoteElement;
24655 "rtc": HTMLElement;
24656 "ruby": HTMLElement;
24658 "samp": HTMLElement;
24659 "script": HTMLScriptElement;
24660 "search": HTMLElement;
24661 "section": HTMLElement;
24662 "select": HTMLSelectElement;
24663 "slot": HTMLSlotElement;
24664 "small": HTMLElement;
24665 "source": HTMLSourceElement;
24666 "span": HTMLSpanElement;
24667 "strike": HTMLElement;
24668 "strong": HTMLElement;
24669 "style": HTMLStyleElement;
24670 "sub": HTMLElement;
24671 "summary": HTMLElement;
24672 "sup": HTMLElement;
24673 "table": HTMLTableElement;
24674 "tbody": HTMLTableSectionElement;
24675 "td": HTMLTableCellElement;
24676 "template": HTMLTemplateElement;
24677 "textarea": HTMLTextAreaElement;
24678 "tfoot": HTMLTableSectionElement;
24679 "th": HTMLTableCellElement;
24680 "thead": HTMLTableSectionElement;
24681 "time": HTMLTimeElement;
24682 "title": HTMLTitleElement;
24683 "tr": HTMLTableRowElement;
24684 "track": HTMLTrackElement;
24687 "ul": HTMLUListElement;
24688 "var": HTMLElement;
24689 "video": HTMLVideoElement;
24690 "wbr": HTMLElement;
24691 "xmp": HTMLPreElement;
24694 interface HTMLElementDeprecatedTagNameMap {
24697 interface SVGElementTagNameMap {
24700 interface MathMLElementTagNameMap {
24703 /** @deprecated Directly use HTMLElementTagNameMap or SVGElementTagNameMap as appropriate, instead. */
24704 type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
24706 declare var Audio: {
24707 new(src?: string): HTMLAudioElement;
24709 declare var Image: {
24710 new(width?: number, height?: number): HTMLImageElement;
24712 declare var Option: {
24713 new(text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement;
24715 declare var webkitSpeechGrammar: {
24716 new(): SpeechGrammar;
24718 declare var webkitSpeechGrammarList: {
24719 new(): SpeechGrammarList;
24721 declare var webkitSpeechRecognition: {
24722 new(): SpeechRecognition;
24724 declare var Glean: GleanImpl;
24725 declare var GleanPings: GleanPingsImpl;
24726 declare var InstallTrigger: InstallTriggerImpl | null;
24727 declare var browserDOMWindow: nsIBrowserDOMWindow | null;
24728 declare var browsingContext: BrowsingContext;
24729 declare var clientInformation: Navigator;
24730 declare var clientPrincipal: Principal | null;
24731 declare var closed: boolean;
24732 declare var content: any;
24733 declare var controllers: XULControllers;
24734 declare var customElements: CustomElementRegistry;
24735 declare var desktopToDeviceScale: number;
24736 declare var devicePixelRatio: number;
24737 declare var docShell: nsIDocShell | null;
24738 declare var document: Document | null;
24739 declare var event: Event | undefined;
24740 declare var external: External;
24741 declare var frameElement: Element | null;
24742 declare var frames: WindowProxy;
24743 declare var fullScreen: boolean;
24744 declare var history: History;
24745 declare var innerHeight: number;
24746 declare var innerWidth: number;
24747 declare var intlUtils: IntlUtils;
24748 declare var isChromeWindow: boolean;
24749 declare var isFullyOccluded: boolean;
24750 declare var isInFullScreenTransition: boolean;
24752 declare var isInstance: IsInstance<Window>;
24753 declare var length: number;
24754 declare var location: Location;
24755 declare var locationbar: BarProp;
24756 declare var menubar: BarProp;
24757 declare var messageManager: ChromeMessageBroadcaster;
24758 declare var mozInnerScreenX: number;
24759 declare var mozInnerScreenY: number;
24761 declare const name: void;
24762 declare var navigator: Navigator;
24763 declare var ondevicelight: ((this: Window, ev: Event) => any) | null;
24764 declare var ondevicemotion: ((this: Window, ev: Event) => any) | null;
24765 declare var ondeviceorientation: ((this: Window, ev: Event) => any) | null;
24766 declare var ondeviceorientationabsolute: ((this: Window, ev: Event) => any) | null;
24767 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
24768 declare var onuserproximity: ((this: Window, ev: Event) => any) | null;
24769 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
24770 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
24771 declare var onvrdisplaydeactivate: ((this: Window, ev: Event) => any) | null;
24772 declare var onvrdisplaydisconnect: ((this: Window, ev: Event) => any) | null;
24773 declare var onvrdisplaypresentchange: ((this: Window, ev: Event) => any) | null;
24774 declare var opener: any;
24775 declare var orientation: number;
24776 declare var outerHeight: number;
24777 declare var outerWidth: number;
24778 declare var pageXOffset: number;
24779 declare var pageYOffset: number;
24780 declare var paintWorklet: Worklet;
24781 declare var parent: WindowProxy | null;
24782 declare var performance: Performance | null;
24783 declare var personalbar: BarProp;
24784 declare var realFrameElement: Element | null;
24785 declare var screen: Screen;
24786 declare var screenEdgeSlopX: number;
24787 declare var screenEdgeSlopY: number;
24788 declare var screenLeft: number;
24789 declare var screenTop: number;
24790 declare var screenX: number;
24791 declare var screenY: number;
24792 declare var scrollMaxX: number;
24793 declare var scrollMaxY: number;
24794 declare var scrollMinX: number;
24795 declare var scrollMinY: number;
24796 declare var scrollX: number;
24797 declare var scrollY: number;
24798 declare var scrollbars: BarProp;
24799 declare var self: WindowProxy;
24800 declare var status: string;
24801 declare var statusbar: BarProp;
24802 declare var toolbar: BarProp;
24803 declare var top: WindowProxy | null;
24804 declare var visualViewport: VisualViewport;
24805 declare var window: WindowProxy;
24806 declare var windowGlobalChild: WindowGlobalChild | null;
24807 declare var windowRoot: WindowRoot | null;
24808 declare var windowState: number;
24809 declare var windowUtils: nsIDOMWindowUtils;
24810 declare function alert(): void;
24811 declare function alert(message: string): void;
24812 declare function blur(): void;
24813 declare function cancelIdleCallback(handle: number): void;
24814 declare function captureEvents(): void;
24815 declare function close(): void;
24816 declare function confirm(message?: string): boolean;
24817 declare function dump(str: string): void;
24818 declare function find(str?: string, caseSensitive?: boolean, backwards?: boolean, wrapAround?: boolean, wholeWord?: boolean, searchInFrames?: boolean, showDialog?: boolean): boolean;
24819 declare function focus(): void;
24820 declare function getAttention(): void;
24821 declare function getAttentionWithCycleCount(aCycleCount: number): void;
24822 declare function getComputedStyle(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration | null;
24823 declare function getDefaultComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration | null;
24824 declare function getGroupMessageManager(aGroup: string): ChromeMessageBroadcaster;
24825 declare function getInterface(iid: any): any;
24826 declare function getRegionalPrefsLocales(): string[];
24827 declare function getSelection(): Selection | null;
24828 declare function getWebExposedLocales(): string[];
24829 declare function getWorkspaceID(): string;
24830 declare function matchMedia(query: string): MediaQueryList | null;
24831 declare function maximize(): void;
24832 declare function minimize(): void;
24833 declare function moveBy(x: number, y: number): void;
24834 declare function moveTo(x: number, y: number): void;
24835 declare function moveToWorkspace(workspaceID: string): void;
24836 declare function mozScrollSnap(): void;
24837 declare function notifyDefaultButtonLoaded(defaultButton: Element): void;
24838 declare function open(url?: string | URL, target?: string, features?: string): WindowProxy | null;
24839 declare function openDialog(url?: string, name?: string, options?: string, ...extraArguments: any[]): WindowProxy | null;
24840 declare function postMessage(message: any, targetOrigin: string, transfer?: any[]): void;
24841 declare function postMessage(message: any, options?: WindowPostMessageOptions): void;
24842 declare function print(): void;
24843 declare function printPreview(settings?: nsIPrintSettings | null, listener?: nsIWebProgressListener | null, docShellToPreviewInto?: nsIDocShell | null): WindowProxy | null;
24844 declare function promiseDocumentFlushed(callback: PromiseDocumentFlushedCallback): Promise<any>;
24845 declare function prompt(message?: string, _default?: string): string | null;
24846 declare function releaseEvents(): void;
24847 declare function requestIdleCallback(callback: IdleRequestCallback, options?: IdleRequestOptions): number;
24848 declare function resizeBy(x: number, y: number): void;
24849 declare function resizeTo(x: number, y: number): void;
24850 declare function restore(): void;
24851 declare function scroll(x: number, y: number): void;
24852 declare function scroll(options?: ScrollToOptions): void;
24853 declare function scrollBy(x: number, y: number): void;
24854 declare function scrollBy(options?: ScrollToOptions): void;
24855 declare function scrollByLines(numLines: number, options?: ScrollOptions): void;
24856 declare function scrollByPages(numPages: number, options?: ScrollOptions): void;
24857 declare function scrollTo(x: number, y: number): void;
24858 declare function scrollTo(options?: ScrollToOptions): void;
24859 declare function setCursor(cursor: string): void;
24860 declare function setResizable(resizable: boolean): void;
24861 declare function setScrollMarks(marks: number[], onHorizontalScrollbar?: boolean): void;
24862 declare function shouldReportForServiceWorkerScope(aScope: string): boolean;
24863 declare function sizeToContent(): void;
24864 declare function sizeToContentConstrained(constraints?: SizeToContentConstraints): void;
24865 declare function stop(): void;
24866 declare function updateCommands(action: string): void;
24867 declare function toString(): string;
24869 declare var isInstance: IsInstance<EventTarget>;
24870 declare var ownerGlobal: WindowProxy | null;
24871 declare function dispatchEvent(event: Event): boolean;
24872 declare function getEventHandler(type: string): EventHandler;
24873 declare function setEventHandler(type: string, handler: EventHandler): void;
24874 declare function cancelAnimationFrame(handle: number): void;
24875 declare function requestAnimationFrame(callback: FrameRequestCallback): number;
24876 declare var crypto: Crypto;
24877 declare var onabort: ((this: Window, ev: Event) => any) | null;
24878 declare var onanimationcancel: ((this: Window, ev: Event) => any) | null;
24879 declare var onanimationend: ((this: Window, ev: Event) => any) | null;
24880 declare var onanimationiteration: ((this: Window, ev: Event) => any) | null;
24881 declare var onanimationstart: ((this: Window, ev: Event) => any) | null;
24882 declare var onauxclick: ((this: Window, ev: Event) => any) | null;
24883 declare var onbeforeinput: ((this: Window, ev: Event) => any) | null;
24884 declare var onbeforetoggle: ((this: Window, ev: Event) => any) | null;
24885 declare var onblur: ((this: Window, ev: Event) => any) | null;
24886 declare var oncancel: ((this: Window, ev: Event) => any) | null;
24887 declare var oncanplay: ((this: Window, ev: Event) => any) | null;
24888 declare var oncanplaythrough: ((this: Window, ev: Event) => any) | null;
24889 declare var onchange: ((this: Window, ev: Event) => any) | null;
24890 declare var onclick: ((this: Window, ev: Event) => any) | null;
24891 declare var onclose: ((this: Window, ev: Event) => any) | null;
24892 declare var oncontextlost: ((this: Window, ev: Event) => any) | null;
24893 declare var oncontextmenu: ((this: Window, ev: Event) => any) | null;
24894 declare var oncontextrestored: ((this: Window, ev: Event) => any) | null;
24895 declare var oncopy: ((this: Window, ev: Event) => any) | null;
24896 declare var oncuechange: ((this: Window, ev: Event) => any) | null;
24897 declare var oncut: ((this: Window, ev: Event) => any) | null;
24898 declare var ondblclick: ((this: Window, ev: Event) => any) | null;
24899 declare var ondrag: ((this: Window, ev: Event) => any) | null;
24900 declare var ondragend: ((this: Window, ev: Event) => any) | null;
24901 declare var ondragenter: ((this: Window, ev: Event) => any) | null;
24902 declare var ondragexit: ((this: Window, ev: Event) => any) | null;
24903 declare var ondragleave: ((this: Window, ev: Event) => any) | null;
24904 declare var ondragover: ((this: Window, ev: Event) => any) | null;
24905 declare var ondragstart: ((this: Window, ev: Event) => any) | null;
24906 declare var ondrop: ((this: Window, ev: Event) => any) | null;
24907 declare var ondurationchange: ((this: Window, ev: Event) => any) | null;
24908 declare var onemptied: ((this: Window, ev: Event) => any) | null;
24909 declare var onended: ((this: Window, ev: Event) => any) | null;
24910 declare var onfocus: ((this: Window, ev: Event) => any) | null;
24911 declare var onformdata: ((this: Window, ev: Event) => any) | null;
24912 declare var ongotpointercapture: ((this: Window, ev: Event) => any) | null;
24913 declare var oninput: ((this: Window, ev: Event) => any) | null;
24914 declare var oninvalid: ((this: Window, ev: Event) => any) | null;
24915 declare var onkeydown: ((this: Window, ev: Event) => any) | null;
24916 declare var onkeypress: ((this: Window, ev: Event) => any) | null;
24917 declare var onkeyup: ((this: Window, ev: Event) => any) | null;
24918 declare var onload: ((this: Window, ev: Event) => any) | null;
24919 declare var onloadeddata: ((this: Window, ev: Event) => any) | null;
24920 declare var onloadedmetadata: ((this: Window, ev: Event) => any) | null;
24921 declare var onloadstart: ((this: Window, ev: Event) => any) | null;
24922 declare var onlostpointercapture: ((this: Window, ev: Event) => any) | null;
24923 declare var onmousedown: ((this: Window, ev: Event) => any) | null;
24924 declare var onmouseenter: ((this: Window, ev: Event) => any) | null;
24925 declare var onmouseleave: ((this: Window, ev: Event) => any) | null;
24926 declare var onmousemove: ((this: Window, ev: Event) => any) | null;
24927 declare var onmouseout: ((this: Window, ev: Event) => any) | null;
24928 declare var onmouseover: ((this: Window, ev: Event) => any) | null;
24929 declare var onmouseup: ((this: Window, ev: Event) => any) | null;
24930 declare var onmozfullscreenchange: ((this: Window, ev: Event) => any) | null;
24931 declare var onmozfullscreenerror: ((this: Window, ev: Event) => any) | null;
24932 declare var onpaste: ((this: Window, ev: Event) => any) | null;
24933 declare var onpause: ((this: Window, ev: Event) => any) | null;
24934 declare var onplay: ((this: Window, ev: Event) => any) | null;
24935 declare var onplaying: ((this: Window, ev: Event) => any) | null;
24936 declare var onpointercancel: ((this: Window, ev: Event) => any) | null;
24937 declare var onpointerdown: ((this: Window, ev: Event) => any) | null;
24938 declare var onpointerenter: ((this: Window, ev: Event) => any) | null;
24939 declare var onpointerleave: ((this: Window, ev: Event) => any) | null;
24940 declare var onpointermove: ((this: Window, ev: Event) => any) | null;
24941 declare var onpointerout: ((this: Window, ev: Event) => any) | null;
24942 declare var onpointerover: ((this: Window, ev: Event) => any) | null;
24943 declare var onpointerup: ((this: Window, ev: Event) => any) | null;
24944 declare var onprogress: ((this: Window, ev: Event) => any) | null;
24945 declare var onratechange: ((this: Window, ev: Event) => any) | null;
24946 declare var onreset: ((this: Window, ev: Event) => any) | null;
24947 declare var onresize: ((this: Window, ev: Event) => any) | null;
24948 declare var onscroll: ((this: Window, ev: Event) => any) | null;
24949 declare var onscrollend: ((this: Window, ev: Event) => any) | null;
24950 declare var onsecuritypolicyviolation: ((this: Window, ev: Event) => any) | null;
24951 declare var onseeked: ((this: Window, ev: Event) => any) | null;
24952 declare var onseeking: ((this: Window, ev: Event) => any) | null;
24953 declare var onselect: ((this: Window, ev: Event) => any) | null;
24954 declare var onselectionchange: ((this: Window, ev: Event) => any) | null;
24955 declare var onselectstart: ((this: Window, ev: Event) => any) | null;
24956 declare var onslotchange: ((this: Window, ev: Event) => any) | null;
24957 declare var onstalled: ((this: Window, ev: Event) => any) | null;
24958 declare var onsubmit: ((this: Window, ev: Event) => any) | null;
24959 declare var onsuspend: ((this: Window, ev: Event) => any) | null;
24960 declare var ontimeupdate: ((this: Window, ev: Event) => any) | null;
24961 declare var ontoggle: ((this: Window, ev: Event) => any) | null;
24962 declare var ontransitioncancel: ((this: Window, ev: Event) => any) | null;
24963 declare var ontransitionend: ((this: Window, ev: Event) => any) | null;
24964 declare var ontransitionrun: ((this: Window, ev: Event) => any) | null;
24965 declare var ontransitionstart: ((this: Window, ev: Event) => any) | null;
24966 declare var onvolumechange: ((this: Window, ev: Event) => any) | null;
24967 declare var onwaiting: ((this: Window, ev: Event) => any) | null;
24968 declare var onwebkitanimationend: ((this: Window, ev: Event) => any) | null;
24969 declare var onwebkitanimationiteration: ((this: Window, ev: Event) => any) | null;
24970 declare var onwebkitanimationstart: ((this: Window, ev: Event) => any) | null;
24971 declare var onwebkittransitionend: ((this: Window, ev: Event) => any) | null;
24972 declare var onwheel: ((this: Window, ev: Event) => any) | null;
24973 declare var onerror: ((this: Window, ev: Event) => any) | null;
24974 declare var speechSynthesis: SpeechSynthesis;
24975 declare var ontouchcancel: ((this: Window, ev: Event) => any) | null;
24976 declare var ontouchend: ((this: Window, ev: Event) => any) | null;
24977 declare var ontouchmove: ((this: Window, ev: Event) => any) | null;
24978 declare var ontouchstart: ((this: Window, ev: Event) => any) | null;
24979 declare var onafterprint: ((this: Window, ev: Event) => any) | null;
24980 declare var onbeforeprint: ((this: Window, ev: Event) => any) | null;
24981 declare var onbeforeunload: ((this: Window, ev: Event) => any) | null;
24982 declare var ongamepadconnected: ((this: Window, ev: Event) => any) | null;
24983 declare var ongamepaddisconnected: ((this: Window, ev: Event) => any) | null;
24984 declare var onhashchange: ((this: Window, ev: Event) => any) | null;
24985 declare var onlanguagechange: ((this: Window, ev: Event) => any) | null;
24986 declare var onmessage: ((this: Window, ev: Event) => any) | null;
24987 declare var onmessageerror: ((this: Window, ev: Event) => any) | null;
24988 declare var onoffline: ((this: Window, ev: Event) => any) | null;
24989 declare var ononline: ((this: Window, ev: Event) => any) | null;
24990 declare var onpagehide: ((this: Window, ev: Event) => any) | null;
24991 declare var onpageshow: ((this: Window, ev: Event) => any) | null;
24992 declare var onpopstate: ((this: Window, ev: Event) => any) | null;
24993 declare var onrejectionhandled: ((this: Window, ev: Event) => any) | null;
24994 declare var onstorage: ((this: Window, ev: Event) => any) | null;
24995 declare var onunhandledrejection: ((this: Window, ev: Event) => any) | null;
24996 declare var onunload: ((this: Window, ev: Event) => any) | null;
24997 declare var localStorage: Storage | null;
24998 declare var caches: CacheStorage;
24999 declare var crossOriginIsolated: boolean;
25000 declare var indexedDB: IDBFactory | null;
25001 declare var isSecureContext: boolean;
25002 declare var origin: string;
25003 declare var scheduler: Scheduler;
25004 declare var trustedTypes: TrustedTypePolicyFactory;
25005 declare function atob(atob: string): string;
25006 declare function btoa(btoa: string): string;
25007 declare function clearInterval(handle?: number): void;
25008 declare function clearTimeout(handle?: number): void;
25009 declare function createImageBitmap(aImage: ImageBitmapSource, aOptions?: ImageBitmapOptions): Promise<ImageBitmap>;
25010 declare function createImageBitmap(aImage: ImageBitmapSource, aSx: number, aSy: number, aSw: number, aSh: number, aOptions?: ImageBitmapOptions): Promise<ImageBitmap>;
25011 declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
25012 declare function queueMicrotask(callback: VoidFunction): void;
25013 declare function reportError(e: any): void;
25014 declare function setInterval(handler: Function, timeout?: number, ...arguments: any[]): number;
25015 declare function setInterval(handler: string, timeout?: number, ...unused: any[]): number;
25016 declare function setTimeout(handler: Function, timeout?: number, ...arguments: any[]): number;
25017 declare function setTimeout(handler: string, timeout?: number, ...unused: any[]): number;
25018 declare function structuredClone(value: any, options?: StructuredSerializeOptions): any;
25019 declare var sessionStorage: Storage | null;
25020 declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
25021 declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
25022 declare function removeEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
25023 declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
25024 type AlgorithmIdentifier = any;
25025 type Base64URLString = string;
25026 type BinaryData = ArrayBuffer | ArrayBufferView;
25027 type BlobPart = BufferSource | Blob | string;
25028 type BodyInit = XMLHttpRequestBodyInit;
25029 type COSEAlgorithmIdentifier = number;
25030 type CanvasImageSource = HTMLOrSVGImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | ImageBitmap | VideoFrame;
25031 type CanvasSource = HTMLCanvasElement | OffscreenCanvas;
25032 type ClipboardItemData = Promise<ClipboardItemDataType>;
25033 type ClipboardItemDataType = string | Blob;
25034 type ClipboardItems = ClipboardItem[];
25035 type CollectedFormDataValue = any;
25036 type ConstrainBoolean = boolean | ConstrainBooleanParameters;
25037 type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
25038 type ConstrainDouble = number | ConstrainDoubleRange;
25039 type ConstrainLong = number | ConstrainLongRange;
25040 type DOMHighResTimeStamp = number;
25041 type DOMTimeStamp = number;
25042 type EpochTimeStamp = number;
25043 type FileSystemWriteChunkType = BufferSource | Blob | string | WriteParams;
25044 type Float32List = Float32Array | GLfloat[];
25045 type FormDataEntryValue = Blob | Directory | string;
25046 type FormDataValue = any;
25047 type GLbitfield = number;
25048 type GLboolean = boolean;
25049 type GLclampf = number;
25050 type GLenum = number;
25051 type GLfloat = number;
25052 type GLint = number;
25053 type GLint64 = number;
25054 type GLintptr = number;
25055 type GLsizei = number;
25056 type GLsizeiptr = number;
25057 type GLuint = number;
25058 type GLuint64 = number;
25059 type GPUBindingResource = GPUSampler | GPUTextureView | GPUBufferBinding;
25060 type GPUBufferDynamicOffset = number;
25061 type GPUBufferUsageFlags = number;
25062 type GPUColor = number[] | GPUColorDict;
25063 type GPUColorWriteFlags = number;
25064 type GPUDepthBias = number;
25065 type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict;
25066 type GPUFlagsConstant = number;
25067 type GPUIndex32 = number;
25068 type GPUIntegerCoordinate = number;
25069 type GPUIntegerCoordinateOut = number;
25070 type GPUMapModeFlags = number;
25071 type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict;
25072 type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict;
25073 type GPUPipelineConstantValue = number;
25074 type GPUSampleMask = number;
25075 type GPUShaderStageFlags = number;
25076 type GPUSignedOffset32 = number;
25077 type GPUSize32 = number;
25078 type GPUSize32Out = number;
25079 type GPUSize64 = number;
25080 type GPUSize64Out = number;
25081 type GPUStencilValue = number;
25082 type GPUTextureUsageFlags = number;
25083 type GeometryNode = Text | Element | Document;
25084 type HTMLOrSVGImageElement = HTMLImageElement | SVGImageElement;
25085 type HeadersInit = string[][] | Record<string, string>;
25086 type HistogramID = string;
25087 type HistogramKey = string;
25088 type ImageBitmapSource = CanvasImageSource | Blob | CanvasRenderingContext2D | ImageData;
25089 type Int32List = Int32Array | GLint[];
25090 type KeyFormat = string;
25091 type KeyType = string;
25092 type KeyUsage = string;
25093 type L10nArgs = Record<string, string | number | null>;
25094 type L10nKey = string | L10nIdArgs;
25095 type L10nResourceId = string | ResourceId;
25096 type MatchGlobOrString = MatchGlob | string;
25097 type MatchPatternSetOrStringSequence = MatchPatternSet | string[];
25098 type MessageEventSource = WindowProxy | MessagePort | ServiceWorker;
25099 type NodeId = number;
25100 type NodeSize = number;
25101 type OffscreenRenderingContext = OffscreenCanvasRenderingContext2D | ImageBitmapRenderingContext | WebGLRenderingContext | WebGL2RenderingContext | GPUCanvasContext;
25102 type OnBeforeUnloadEventHandler = OnBeforeUnloadEventHandlerNonNull | null;
25103 type OnErrorEventHandler = OnErrorEventHandlerNonNull | null;
25104 type PerformanceEntryList = PerformanceEntry[];
25105 type RTCRtpTransform = RTCRtpScriptTransform;
25106 type ReadableStreamReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader;
25107 type ReportList = Report[];
25108 type RequestInfo = Request | string;
25109 type SanitizerAttribute = string | SanitizerAttributeNamespace;
25110 type SanitizerElement = string | SanitizerElementNamespace;
25111 type SanitizerElementWithAttributes = string | SanitizerElementNamespaceWithAttributes;
25112 type SanitizerInput = DocumentFragment | Document;
25113 type StringOrOpenPopupOptions = string | OpenPopupOptions;
25114 type StructuredClonable = any;
25115 type Uint32List = Uint32Array | GLuint[];
25116 type UniFFICallbackInterfaceId = number;
25117 type UniFFICallbackMethodId = number;
25118 type UniFFICallbackObjectHandle = number;
25119 type UniFFIFunctionId = number;
25120 type UniFFIPointerId = number;
25121 type UniFFIScaffoldingValue = number | ArrayBuffer | UniFFIPointer;
25122 type UnrestrictedDoubleOrKeyframeAnimationOptions = number | KeyframeAnimationOptions;
25123 type VibratePattern = number | number[];
25124 type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string;
25125 type XRWebGLRenderingContext = WebGLRenderingContext | WebGL2RenderingContext;
25126 type XSLTParameterValue = number | boolean | string | Node | Node[] | XPathResult;
25127 type nsContentPolicyType = number;
25128 type AlignSetting = "center" | "end" | "left" | "right" | "start";
25129 type AlphaOption = "discard" | "keep";
25130 type AnimationPlayState = "finished" | "idle" | "paused" | "running";
25131 type AnimationReplaceState = "active" | "persisted" | "removed";
25132 type AudioContextState = "closed" | "running" | "suspended";
25133 type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar";
25134 type AutoKeyword = "auto";
25135 type AutoplayPolicy = "allowed" | "allowed-muted" | "disallowed";
25136 type AutoplayPolicyMediaType = "audiocontext" | "mediaelement";
25137 type AvcBitstreamFormat = "annexb" | "avc";
25138 type Base64URLDecodePadding = "ignore" | "reject" | "require";
25139 type BinaryType = "arraybuffer" | "blob";
25140 type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking";
25141 type BitrateMode = "constant" | "variable";
25142 type CSSBoxType = "border" | "content" | "margin" | "padding";
25143 type CSSStyleSheetParsingMode = "agent" | "author" | "user";
25144 type CacheStorageNamespace = "chrome" | "content";
25145 type CallbackDebuggerNotificationPhase = "post" | "pre";
25146 type CanvasDirection = "inherit" | "ltr" | "rtl";
25147 type CanvasFontKerning = "auto" | "none" | "normal";
25148 type CanvasFontStretch = "condensed" | "expanded" | "extra-condensed" | "extra-expanded" | "normal" | "semi-condensed" | "semi-expanded" | "ultra-condensed" | "ultra-expanded";
25149 type CanvasFontVariantCaps = "all-petite-caps" | "all-small-caps" | "normal" | "petite-caps" | "small-caps" | "titling-caps" | "unicase";
25150 type CanvasLineCap = "butt" | "round" | "square";
25151 type CanvasLineJoin = "bevel" | "miter" | "round";
25152 type CanvasTextAlign = "center" | "end" | "left" | "right" | "start";
25153 type CanvasTextBaseline = "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top";
25154 type CanvasTextRendering = "auto" | "geometricPrecision" | "optimizeLegibility" | "optimizeSpeed";
25155 type CanvasWindingRule = "evenodd" | "nonzero";
25156 type CaretChangedReason = "dragcaret" | "longpressonemptycontent" | "presscaret" | "releasecaret" | "scroll" | "taponcaret" | "updateposition" | "visibilitychange";
25157 type ChannelCountMode = "clamped-max" | "explicit" | "max";
25158 type ChannelInterpretation = "discrete" | "speakers";
25159 type CheckerboardReason = "recent" | "severe";
25160 type CodecState = "closed" | "configured" | "unconfigured";
25161 type ColorGamut = "p3" | "rec2020" | "srgb";
25162 type ColorSpaceConversion = "default" | "none";
25163 type CompositeOperation = "accumulate" | "add" | "replace";
25164 type CompressionFormat = "deflate" | "deflate-raw" | "gzip";
25165 type ConnectionType = "bluetooth" | "cellular" | "ethernet" | "none" | "other" | "unknown" | "wifi";
25166 type ConsoleLevel = "error" | "log" | "warning";
25167 type ConsoleLogLevel = "All" | "Clear" | "Debug" | "Dir" | "Dirxml" | "Error" | "Group" | "GroupEnd" | "Info" | "Log" | "Off" | "Profile" | "ProfileEnd" | "Time" | "TimeEnd" | "TimeLog" | "Trace" | "Warn";
25168 type ContentScriptExecutionWorld = "ISOLATED" | "MAIN";
25169 type ContentScriptRunAt = "document_end" | "document_idle" | "document_start";
25170 type CredentialMediationRequirement = "conditional" | "optional" | "required" | "silent";
25171 type DebuggerNotificationType = "cancelAnimationFrame" | "clearInterval" | "clearTimeout" | "domEvent" | "requestAnimationFrame" | "requestAnimationFrameCallback" | "setInterval" | "setIntervalCallback" | "setTimeout" | "setTimeoutCallback";
25172 type DecoderDoctorReportType = "mediacannotinitializepulseaudio" | "mediacannotplaynodecoders" | "mediadecodeerror" | "mediadecodewarning" | "medianodecoders" | "mediaplatformdecodernotfound" | "mediaunsupportedlibavcodec" | "mediawidevinenowmf" | "mediawmfneeded";
25173 type DirectionSetting = "" | "lr" | "rl";
25174 type DisplayMode = "browser" | "fullscreen" | "minimal-ui" | "standalone";
25175 type DistanceModelType = "exponential" | "inverse" | "linear";
25176 type EncodedAudioChunkType = "delta" | "key";
25177 type EncodedVideoChunkType = "delta" | "key";
25178 type EndingType = "native" | "transparent";
25179 type EventCallbackDebuggerNotificationType = "global" | "node" | "websocket" | "worker" | "xhr";
25180 type FetchState = "aborted" | "complete" | "errored" | "requesting" | "responding";
25181 type FileSystemHandleKind = "directory" | "file";
25182 type FileType = "directory" | "other" | "regular";
25183 type FillMode = "auto" | "backwards" | "both" | "forwards" | "none";
25184 type FlexItemClampState = "clamped_to_max" | "clamped_to_min" | "unclamped";
25185 type FlexLineGrowthState = "growing" | "shrinking";
25186 type FlexPhysicalDirection = "horizontal-lr" | "horizontal-rl" | "vertical-bt" | "vertical-tb";
25187 type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded";
25188 type FontFaceSetLoadStatus = "loaded" | "loading";
25189 type GPUAddressMode = "clamp-to-edge" | "mirror-repeat" | "repeat";
25190 type GPUAutoLayoutMode = "auto";
25191 type GPUBlendFactor = "constant" | "dst" | "dst-alpha" | "one" | "one-minus-constant" | "one-minus-dst" | "one-minus-dst-alpha" | "one-minus-src" | "one-minus-src-alpha" | "src" | "src-alpha" | "src-alpha-saturated" | "zero";
25192 type GPUBlendOperation = "add" | "max" | "min" | "reverse-subtract" | "subtract";
25193 type GPUBufferBindingType = "read-only-storage" | "storage" | "uniform";
25194 type GPUBufferMapState = "mapped" | "pending" | "unmapped";
25195 type GPUCanvasAlphaMode = "opaque" | "premultiplied";
25196 type GPUCompareFunction = "always" | "equal" | "greater" | "greater-equal" | "less" | "less-equal" | "never" | "not-equal";
25197 type GPUCompilationMessageType = "error" | "info" | "warning";
25198 type GPUCullMode = "back" | "front" | "none";
25199 type GPUErrorFilter = "internal" | "out-of-memory" | "validation";
25200 type GPUFeatureName = "bgra8unorm-storage" | "depth-clip-control" | "depth32float-stencil8" | "float32-filterable" | "indirect-first-instance" | "rg11b10ufloat-renderable" | "shader-f16" | "texture-compression-astc" | "texture-compression-bc" | "texture-compression-etc2" | "timestamp-query";
25201 type GPUFilterMode = "linear" | "nearest";
25202 type GPUFrontFace = "ccw" | "cw";
25203 type GPUIndexFormat = "uint16" | "uint32";
25204 type GPULoadOp = "clear" | "load";
25205 type GPUMipmapFilterMode = "linear" | "nearest";
25206 type GPUPowerPreference = "high-performance" | "low-power";
25207 type GPUPrimitiveTopology = "line-list" | "line-strip" | "point-list" | "triangle-list" | "triangle-strip";
25208 type GPUSamplerBindingType = "comparison" | "filtering" | "non-filtering";
25209 type GPUStencilOperation = "decrement-clamp" | "decrement-wrap" | "increment-clamp" | "increment-wrap" | "invert" | "keep" | "replace" | "zero";
25210 type GPUStorageTextureAccess = "read-only" | "read-write" | "write-only";
25211 type GPUStoreOp = "discard" | "store";
25212 type GPUTextureAspect = "all" | "depth-only" | "stencil-only";
25213 type GPUTextureDimension = "1d" | "2d" | "3d";
25214 type GPUTextureFormat = "bc1-rgba-unorm" | "bc1-rgba-unorm-srgb" | "bc2-rgba-unorm" | "bc2-rgba-unorm-srgb" | "bc3-rgba-unorm" | "bc3-rgba-unorm-srgb" | "bc4-r-snorm" | "bc4-r-unorm" | "bc5-rg-snorm" | "bc5-rg-unorm" | "bc6h-rgb-float" | "bc6h-rgb-ufloat" | "bc7-rgba-unorm" | "bc7-rgba-unorm-srgb" | "bgra8unorm" | "bgra8unorm-srgb" | "depth16unorm" | "depth24plus" | "depth24plus-stencil8" | "depth32float" | "depth32float-stencil8" | "r16float" | "r16sint" | "r16uint" | "r32float" | "r32sint" | "r32uint" | "r8sint" | "r8snorm" | "r8uint" | "r8unorm" | "rg11b10ufloat" | "rg16float" | "rg16sint" | "rg16uint" | "rg32float" | "rg32sint" | "rg32uint" | "rg8sint" | "rg8snorm" | "rg8uint" | "rg8unorm" | "rgb10a2unorm" | "rgb9e5ufloat" | "rgba16float" | "rgba16sint" | "rgba16uint" | "rgba32float" | "rgba32sint" | "rgba32uint" | "rgba8sint" | "rgba8snorm" | "rgba8uint" | "rgba8unorm" | "rgba8unorm-srgb" | "stencil8";
25215 type GPUTextureSampleType = "depth" | "float" | "sint" | "uint" | "unfilterable-float";
25216 type GPUTextureViewDimension = "1d" | "2d" | "2d-array" | "3d" | "cube" | "cube-array";
25217 type GPUVertexFormat = "float16x2" | "float16x4" | "float32" | "float32x2" | "float32x3" | "float32x4" | "sint16x2" | "sint16x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4" | "sint8x2" | "sint8x4" | "snorm16x2" | "snorm16x4" | "snorm8x2" | "snorm8x4" | "uint16x2" | "uint16x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "uint8x2" | "uint8x4" | "unorm16x2" | "unorm16x4" | "unorm8x2" | "unorm8x4";
25218 type GPUVertexStepMode = "instance" | "vertex";
25219 type GamepadHand = "" | "left" | "right";
25220 type GamepadHapticActuatorType = "vibration";
25221 type GamepadLightIndicatorType = "on-off" | "rgb";
25222 type GamepadMappingType = "" | "standard" | "xr-standard";
25223 type GetUserMediaRequestType = "getusermedia" | "recording-device-stopped" | "selectaudiooutput";
25224 type GridDeclaration = "explicit" | "implicit";
25225 type GridTrackState = "removed" | "repeat" | "static";
25226 type HDCPVersion = "1.0" | "1.1" | "1.2" | "1.3" | "1.4" | "2.0" | "2.1" | "2.2" | "2.3";
25227 type HardwareAcceleration = "no-preference" | "prefer-hardware" | "prefer-software";
25228 type HashAlgorithm = "sha256" | "sha384" | "sha512";
25229 type HdrMetadataType = "smpteSt2086" | "smpteSt2094-10" | "smpteSt2094-40";
25230 type HeadersGuardEnum = "immutable" | "none" | "request" | "request-no-cors" | "response";
25231 type HighlightType = "grammar-error" | "highlight" | "spelling-error";
25232 type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
25233 type IDBRequestReadyState = "done" | "pending";
25234 type IDBTransactionDurability = "default" | "relaxed" | "strict";
25235 type IDBTransactionMode = "cleanup" | "readonly" | "readwrite" | "readwriteflush" | "versionchange";
25236 type ImageOrientation = "flipY" | "from-image" | "none";
25237 type ImportESModuleTargetGlobal = "contextual" | "current" | "devtools" | "shared";
25238 type InspectorPropertyType = "color" | "gradient" | "timing-function";
25239 type IterationCompositeOperation = "accumulate" | "replace";
25240 type JSRFPTarget = "RoundWindowSize" | "SiteSpecificZoom";
25241 type L10nFileSourceHasFileStatus = "missing" | "present" | "unknown";
25242 type LatencyMode = "quality" | "realtime";
25243 type LineAlignSetting = "center" | "end" | "start";
25244 type LockMode = "exclusive" | "shared";
25245 type MIDIPortConnectionState = "closed" | "open" | "pending";
25246 type MIDIPortDeviceState = "connected" | "disconnected";
25247 type MIDIPortType = "input" | "output";
25248 type MediaControlKey = "focus" | "nexttrack" | "pause" | "play" | "playpause" | "previoustrack" | "seekbackward" | "seekforward" | "seekto" | "skipad" | "stop";
25249 type MediaDecodingType = "file" | "media-source";
25250 type MediaDeviceKind = "audioinput" | "audiooutput" | "videoinput";
25251 type MediaEncodingType = "record" | "transmission";
25252 type MediaKeyMessageType = "individualization-request" | "license-release" | "license-renewal" | "license-request";
25253 type MediaKeySessionType = "persistent-license" | "temporary";
25254 type MediaKeyStatus = "expired" | "internal-error" | "output-downscaled" | "output-restricted" | "released" | "status-pending" | "usable";
25255 type MediaKeysRequirement = "not-allowed" | "optional" | "required";
25256 type MediaSessionAction = "nexttrack" | "pause" | "play" | "previoustrack" | "seekbackward" | "seekforward" | "seekto" | "skipad" | "stop";
25257 type MediaSessionPlaybackState = "none" | "paused" | "playing";
25258 type MediaSourceEndOfStreamError = "decode" | "network";
25259 type MediaSourceReadyState = "closed" | "ended" | "open";
25260 type MediaStreamTrackState = "ended" | "live";
25261 type MozContentPolicyType = "beacon" | "csp_report" | "fetch" | "font" | "image" | "imageset" | "main_frame" | "media" | "object" | "object_subrequest" | "other" | "ping" | "script" | "speculative" | "stylesheet" | "sub_frame" | "web_manifest" | "websocket" | "xml_dtd" | "xmlhttprequest" | "xslt";
25262 type MozUrlClassificationFlags = "any_basic_tracking" | "any_social_tracking" | "any_strict_tracking" | "cryptomining" | "cryptomining_content" | "emailtracking" | "emailtracking_content" | "fingerprinting" | "fingerprinting_content" | "socialtracking" | "socialtracking_facebook" | "socialtracking_linkedin" | "socialtracking_twitter" | "tracking" | "tracking_ad" | "tracking_analytics" | "tracking_content" | "tracking_social";
25263 type NavigationType = "back_forward" | "navigate" | "prerender" | "reload";
25264 type NotificationDirection = "auto" | "ltr" | "rtl";
25265 type NotificationPermission = "default" | "denied" | "granted";
25266 type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu";
25267 type OpusBitstreamFormat = "ogg" | "opus";
25268 type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary";
25269 type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary";
25270 type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle";
25271 type OverSampleType = "2x" | "4x" | "none";
25272 type OverridableErrorCategory = "domain-mismatch" | "expired-or-not-yet-valid" | "trust-error" | "unset";
25273 type PCError = "InvalidAccessError" | "InvalidCharacterError" | "InvalidModificationError" | "InvalidStateError" | "NotReadableError" | "NotSupportedError" | "OperationError" | "RangeError" | "SyntaxError" | "TypeError" | "UnknownError";
25274 type PCObserverStateType = "ConnectionState" | "IceConnectionState" | "IceGatheringState" | "None" | "SignalingState";
25275 type PanningModelType = "HRTF" | "equalpower";
25276 type PaymentComplete = "fail" | "success" | "unknown";
25277 type PaymentShippingType = "delivery" | "pickup" | "shipping";
25278 type PermissionName = "geolocation" | "midi" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "storage-access";
25279 type PermissionState = "denied" | "granted" | "prompt";
25280 type PermitUnloadAction = "dontUnload" | "prompt" | "unload";
25281 type PlacesEventType = "bookmark-added" | "bookmark-guid-changed" | "bookmark-keyword-changed" | "bookmark-moved" | "bookmark-removed" | "bookmark-tags-changed" | "bookmark-time-changed" | "bookmark-title-changed" | "bookmark-url-changed" | "favicon-changed" | "history-cleared" | "none" | "page-removed" | "page-title-changed" | "page-visited" | "pages-rank-changed" | "purge-caches";
25282 type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse";
25283 type PopupBlockerState = "openAbused" | "openAllowed" | "openBlocked" | "openControlled" | "openOverridden";
25284 type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right";
25285 type PredefinedColorSpace = "display-p3" | "srgb";
25286 type PrefersColorSchemeOverride = "dark" | "light" | "none";
25287 type PremultiplyAlpha = "default" | "none" | "premultiply";
25288 type PresentationStyle = "attachment" | "inline" | "unspecified";
25289 type PrivateAttributionImpressionType = "click" | "view";
25290 type PromiseDebuggingState = "fulfilled" | "pending" | "rejected";
25291 type PushEncryptionKeyName = "auth" | "p256dh";
25292 type RTCBundlePolicy = "balanced" | "max-bundle" | "max-compat";
25293 type RTCCodecType = "decode" | "encode";
25294 type RTCDataChannelState = "closed" | "closing" | "connecting" | "open";
25295 type RTCDataChannelType = "arraybuffer" | "blob";
25296 type RTCDtlsTransportState = "closed" | "connected" | "connecting" | "failed" | "new";
25297 type RTCEncodedVideoFrameType = "delta" | "empty" | "key";
25298 type RTCIceCandidateType = "host" | "prflx" | "relay" | "srflx";
25299 type RTCIceComponent = "rtcp" | "rtp";
25300 type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
25301 type RTCIceCredentialType = "password";
25302 type RTCIceGathererState = "complete" | "gathering" | "new";
25303 type RTCIceGatheringState = "complete" | "gathering" | "new";
25304 type RTCIceProtocol = "tcp" | "udp";
25305 type RTCIceTcpCandidateType = "active" | "passive" | "so";
25306 type RTCIceTransportPolicy = "all" | "relay";
25307 type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
25308 type RTCLifecycleEvent = "connectionstatechange" | "iceconnectionstatechange" | "icegatheringstatechange" | "initialized";
25309 type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
25310 type RTCPriorityType = "high" | "low" | "medium" | "very-low";
25311 type RTCRtpTransceiverDirection = "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped";
25312 type RTCSctpTransportState = "closed" | "connected" | "connecting";
25313 type RTCSdpType = "answer" | "offer" | "pranswer" | "rollback";
25314 type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
25315 type RTCStatsIceCandidatePairState = "cancelled" | "failed" | "frozen" | "inprogress" | "succeeded" | "waiting";
25316 type RTCStatsType = "candidate-pair" | "codec" | "csrc" | "data-channel" | "inbound-rtp" | "local-candidate" | "media-source" | "outbound-rtp" | "peer-connection" | "remote-candidate" | "remote-inbound-rtp" | "remote-outbound-rtp" | "session" | "track" | "transport";
25317 type ReadableStreamReaderMode = "byob";
25318 type RecordingState = "inactive" | "paused" | "recording";
25319 type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
25320 type RenderBlockingStatusType = "blocking" | "non-blocking";
25321 type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
25322 type RequestCredentials = "include" | "omit" | "same-origin";
25323 type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
25324 type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
25325 type RequestPriority = "auto" | "high" | "low";
25326 type RequestRedirect = "error" | "follow" | "manual";
25327 type ResizeObserverBoxOptions = "border-box" | "content-box" | "device-pixel-content-box";
25328 type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
25329 type ScreenColorGamut = "p3" | "rec2020" | "srgb";
25330 type ScrollBehavior = "auto" | "instant" | "smooth";
25331 type ScrollLogicalPosition = "center" | "end" | "nearest" | "start";
25332 type ScrollRestoration = "auto" | "manual";
25333 type ScrollSetting = "" | "up";
25334 type ScrollState = "started" | "stopped";
25335 type SecurityPolicyViolationEventDisposition = "enforce" | "report";
25336 type SelectionMode = "end" | "preserve" | "select" | "start";
25337 type SelectorWarningKind = "UnconstrainedHas";
25338 type ServiceWorkerState = "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant";
25339 type ServiceWorkerUpdateViaCache = "all" | "imports" | "none";
25340 type ShadowRootMode = "closed" | "open";
25341 type SlotAssignmentMode = "manual" | "named";
25342 type SocketReadyState = "closed" | "closing" | "halfclosed" | "open" | "opening";
25343 type SourceBufferAppendMode = "segments" | "sequence";
25344 type SpeechRecognitionErrorCode = "aborted" | "audio-capture" | "bad-grammar" | "language-not-supported" | "network" | "no-speech" | "not-allowed" | "service-not-allowed";
25345 type SpeechSynthesisErrorCode = "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable";
25346 type StreamFilterStatus = "closed" | "disconnected" | "failed" | "finishedtransferringdata" | "suspended" | "transferringdata" | "uninitialized";
25347 type StringType = "inline" | "literal" | "other" | "stringbuffer";
25348 type SupportedType = "application/xhtml+xml" | "application/xml" | "image/svg+xml" | "text/html" | "text/xml";
25349 type TCPReadyState = "closed" | "closing" | "connecting" | "open";
25350 type TCPSocketBinaryType = "arraybuffer" | "string";
25351 type TaskPriority = "background" | "user-blocking" | "user-visible";
25352 type TextTrackKind = "captions" | "chapters" | "descriptions" | "metadata" | "subtitles";
25353 type TextTrackMode = "disabled" | "hidden" | "showing";
25354 type TouchEventsOverride = "disabled" | "enabled" | "none";
25355 type TransferFunction = "hlg" | "pq" | "srgb";
25356 type UniFFIScaffoldingCallCode = "error" | "internal-error" | "success";
25357 type VRDisplayEventReason = "mounted" | "navigation" | "requested" | "unmounted";
25358 type VREye = "left" | "right";
25359 type VideoColorPrimaries = "bt2020" | "bt470bg" | "bt709" | "smpte170m" | "smpte432";
25360 type VideoEncoderBitrateMode = "constant" | "quantizer" | "variable";
25361 type VideoMatrixCoefficients = "bt2020-ncl" | "bt470bg" | "bt709" | "rgb" | "smpte170m";
25362 type VideoPixelFormat = "BGRA" | "BGRX" | "I420" | "I420A" | "I422" | "I444" | "NV12" | "RGBA" | "RGBX";
25363 type VideoTransferCharacteristics = "bt709" | "hlg" | "iec61966-2-1" | "linear" | "pq" | "smpte170m";
25364 type VisibilityState = "hidden" | "visible";
25365 type WakeLockType = "screen";
25366 type WebGLPowerPreference = "default" | "high-performance" | "low-power";
25367 type WebIDLProcType = "browser" | "extension" | "file" | "forkServer" | "gmpPlugin" | "gpu" | "ipdlUnitTest" | "preallocated" | "privilegedabout" | "privilegedmozilla" | "rdd" | "remoteSandboxBroker" | "socket" | "unknown" | "utility" | "vr" | "web" | "webIsolated" | "webServiceWorker" | "withCoopCoep";
25368 type WebIDLUtilityActorName = "audioDecoder_AppleMedia" | "audioDecoder_Generic" | "audioDecoder_WMF" | "jSOracle" | "mfMediaEngineCDM" | "unknown" | "windowsFileDialog" | "windowsUtils";
25369 type WebTransportCongestionControl = "default" | "low-latency" | "throughput";
25370 type WebTransportErrorSource = "session" | "stream";
25371 type WebTransportReliabilityMode = "pending" | "reliable-only" | "supports-unreliable";
25372 type WireframeRectType = "background" | "image" | "text" | "unknown";
25373 type WorkerType = "classic" | "module";
25374 type WriteCommandType = "seek" | "truncate" | "write";
25375 type WriteMode = "append" | "appendOrCreate" | "create" | "overwrite";
25376 type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
25377 type XREye = "left" | "none" | "right";
25378 type XRHandedness = "left" | "none" | "right";
25379 type XRReferenceSpaceType = "bounded-floor" | "local" | "local-floor" | "unbounded" | "viewer";
25380 type XRSessionMode = "immersive-ar" | "immersive-vr" | "inline";
25381 type XRTargetRayMode = "gaze" | "screen" | "tracked-pointer";
25382 type XRVisibilityState = "hidden" | "visible" | "visible-blurred";
25383 type mozPacketDumpType = "rtcp" | "rtp" | "srtcp" | "srtp";
25385 /////////////////////////////
25386 /// Window Iterable APIs
25387 /////////////////////////////
25389 interface AbortSignal {
25390 any(signals: Iterable<AbortSignal>): AbortSignal;
25393 interface AudioParam {
25394 setValueCurveAtTime(values: Iterable<number>, startTime: number, duration: number): AudioParam;
25397 interface AudioParamMap extends ReadonlyMap<string, AudioParam> {
25400 interface AudioTrackList {
25401 [Symbol.iterator](): IterableIterator<AudioTrack>;
25404 interface BaseAudioContext {
25405 createIIRFilter(feedforward: Iterable<number>, feedback: Iterable<number>): IIRFilterNode;
25406 createPeriodicWave(real: Iterable<number>, imag: Iterable<number>, constraints?: PeriodicWaveConstraints): PeriodicWave;
25409 interface CSSKeyframesRule {
25410 [Symbol.iterator](): IterableIterator<CSSKeyframeRule>;
25413 interface CSSRuleList {
25414 [Symbol.iterator](): IterableIterator<CSSRule>;
25417 interface CSSStyleDeclaration {
25418 [Symbol.iterator](): IterableIterator<string>;
25422 addAll(requests: Iterable<RequestInfo>): Promise<void>;
25425 interface CanonicalBrowsingContext {
25426 countSiteOrigins(roots: Iterable<BrowsingContext>): number;
25429 interface CanvasPathDrawingStyles {
25430 setLineDash(segments: Iterable<number>): void;
25433 interface CanvasPathMethods {
25434 roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | Iterable<number | DOMPointInit>): void;
25437 interface CustomStateSet extends Set<string> {
25440 interface DOMLocalization {
25441 translateElements(aElements: Iterable<Element>): Promise<void>;
25444 interface DOMParser {
25445 parseFromBuffer(buf: Iterable<number>, type: SupportedType): Document;
25448 interface DOMRectList {
25449 [Symbol.iterator](): IterableIterator<DOMRect>;
25452 interface DOMStringList {
25453 [Symbol.iterator](): IterableIterator<string>;
25456 interface DOMTokenList {
25457 [Symbol.iterator](): IterableIterator<string | null>;
25458 entries(): IterableIterator<[number, string | null]>;
25459 keys(): IterableIterator<number>;
25460 values(): IterableIterator<string | null>;
25463 interface DataTransferItemList {
25464 [Symbol.iterator](): IterableIterator<DataTransferItem>;
25467 interface Document {
25468 createTouchList(touches: Iterable<Touch>): TouchList;
25471 interface EventCounts extends ReadonlyMap<string, number> {
25474 interface FileList {
25475 [Symbol.iterator](): IterableIterator<File>;
25478 interface FormData {
25479 [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
25480 entries(): IterableIterator<[string, FormDataEntryValue]>;
25481 keys(): IterableIterator<string>;
25482 values(): IterableIterator<FormDataEntryValue>;
25485 interface GPUAdapter {
25486 requestAdapterInfo(unmaskHints?: Iterable<string>): Promise<GPUAdapterInfo>;
25489 interface GPUBindingCommandsMixin {
25490 setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup, dynamicOffsets?: Iterable<GPUBufferDynamicOffset>): void;
25493 interface GPUCommandEncoder {
25494 copyBufferToTexture(source: GPUImageCopyBuffer, destination: GPUImageCopyTexture, copySize: Iterable<GPUIntegerCoordinate>): void;
25495 copyTextureToBuffer(source: GPUImageCopyTexture, destination: GPUImageCopyBuffer, copySize: Iterable<GPUIntegerCoordinate>): void;
25496 copyTextureToTexture(source: GPUImageCopyTexture, destination: GPUImageCopyTexture, copySize: Iterable<GPUIntegerCoordinate>): void;
25499 interface GPUQueue {
25500 copyExternalImageToTexture(source: GPUImageCopyExternalImage, destination: GPUImageCopyTextureTagged, copySize: Iterable<GPUIntegerCoordinate>): void;
25501 submit(buffers: Iterable<GPUCommandBuffer>): void;
25502 writeTexture(destination: GPUImageCopyTexture, data: BufferSource, dataLayout: GPUImageDataLayout, size: Iterable<GPUIntegerCoordinate>): void;
25505 interface GPURenderPassEncoder {
25506 executeBundles(bundles: Iterable<GPURenderBundle>): void;
25507 setBlendConstant(color: Iterable<number>): void;
25510 interface GPUSupportedFeatures extends ReadonlySet<string> {
25513 interface GleanCustomDistribution {
25514 accumulateSamples(aSamples: Iterable<number>): void;
25517 interface GleanStringList {
25518 set(aValue: Iterable<string>): void;
25521 interface GridLines {
25522 [Symbol.iterator](): IterableIterator<GridLine>;
25525 interface GridTracks {
25526 [Symbol.iterator](): IterableIterator<GridTrack>;
25529 interface HTMLAllCollection {
25530 [Symbol.iterator](): IterableIterator<Element>;
25533 interface HTMLCollectionBase {
25534 [Symbol.iterator](): IterableIterator<Element>;
25537 interface HTMLFormElement {
25538 [Symbol.iterator](): IterableIterator<Element>;
25541 interface HTMLInputElement {
25542 mozSetDndFilesAndDirectories(list: Iterable<File | Directory>): void;
25543 mozSetFileArray(files: Iterable<File>): void;
25544 mozSetFileNameArray(fileNames: Iterable<string>): void;
25547 interface HTMLSelectElement {
25548 [Symbol.iterator](): IterableIterator<Element>;
25551 interface Headers {
25552 [Symbol.iterator](): IterableIterator<[string, string]>;
25553 entries(): IterableIterator<[string, string]>;
25554 keys(): IterableIterator<string>;
25555 values(): IterableIterator<string>;
25558 interface HeapSnapshot {
25559 computeShortestPaths(start: NodeId, targets: Iterable<NodeId>, maxNumPaths: number): any;
25562 interface Highlight extends Set<AbstractRange> {
25565 interface HighlightRegistry extends Map<string, Highlight> {
25568 interface IDBDatabase {
25569 transaction(storeNames: string | Iterable<string>, mode?: IDBTransactionMode, options?: IDBTransactionOptions): IDBTransaction;
25572 interface IDBObjectStore {
25573 createIndex(name: string, keyPath: string | Iterable<string>, optionalParameters?: IDBIndexParameters): IDBIndex;
25576 interface IntlUtils {
25577 getDisplayNames(locales: Iterable<string>, options?: DisplayNameOptions): DisplayNameResult;
25580 interface L10nFileSource {
25581 createMock(name: string, metasource: string, locales: Iterable<string>, prePath: string, fs: Iterable<L10nFileSourceMockFile>): L10nFileSource;
25584 interface L10nRegistry {
25585 generateBundles(aLocales: Iterable<string>, aResourceIds: Iterable<L10nResourceId>): FluentBundleAsyncIterator;
25586 generateBundlesSync(aLocales: Iterable<string>, aResourceIds: Iterable<L10nResourceId>): FluentBundleIterator;
25587 registerSources(aSources: Iterable<L10nFileSource>): void;
25588 removeSources(aSources: Iterable<string>): void;
25589 updateSources(aSources: Iterable<L10nFileSource>): void;
25592 interface Localization {
25593 addResourceIds(aResourceIds: Iterable<L10nResourceId>): void;
25594 formatMessages(aKeys: Iterable<L10nKey>): Promise<Iterable<L10nMessage | null>>;
25595 formatMessagesSync(aKeys: Iterable<L10nKey>): Iterable<L10nMessage | null>;
25596 formatValues(aKeys: Iterable<L10nKey>): Promise<Iterable<string | null>>;
25597 formatValuesSync(aKeys: Iterable<L10nKey>): Iterable<string | null>;
25598 removeResourceIds(aResourceIds: Iterable<L10nResourceId>): number;
25601 interface MIDIInputMap extends ReadonlyMap<string, MIDIInput> {
25604 interface MIDIOutput {
25605 send(data: Iterable<number>, timestamp?: DOMHighResTimeStamp): void;
25608 interface MIDIOutputMap extends ReadonlyMap<string, MIDIOutput> {
25611 interface MediaKeyStatusMap {
25612 [Symbol.iterator](): IterableIterator<[ArrayBuffer, MediaKeyStatus]>;
25613 entries(): IterableIterator<[ArrayBuffer, MediaKeyStatus]>;
25614 keys(): IterableIterator<ArrayBuffer>;
25615 values(): IterableIterator<MediaKeyStatus>;
25618 interface MediaList {
25619 [Symbol.iterator](): IterableIterator<string>;
25622 interface MessageEvent {
25623 initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: Iterable<MessagePort>): void;
25626 interface MessagePort {
25627 postMessage(message: any, transferable: Iterable<any>): void;
25630 interface MimeTypeArray {
25631 [Symbol.iterator](): IterableIterator<MimeType>;
25634 interface MozDocumentObserver {
25635 observe(matchers: Iterable<MozDocumentMatcher>): void;
25638 interface MozSharedMap {
25639 [Symbol.iterator](): IterableIterator<[string, StructuredClonable]>;
25640 entries(): IterableIterator<[string, StructuredClonable]>;
25641 keys(): IterableIterator<string>;
25642 values(): IterableIterator<StructuredClonable>;
25645 interface MozStorageAsyncStatementParams {
25646 [Symbol.iterator](): IterableIterator<any>;
25649 interface MozStorageStatementParams {
25650 [Symbol.iterator](): IterableIterator<any>;
25653 interface NamedNodeMap {
25654 [Symbol.iterator](): IterableIterator<Attr>;
25657 interface Navigator {
25658 requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: Iterable<MediaKeySystemConfiguration>): Promise<MediaKeySystemAccess>;
25659 vibrate(pattern: Iterable<number>): boolean;
25662 interface NodeList {
25663 [Symbol.iterator](): IterableIterator<Node | null>;
25664 entries(): IterableIterator<[number, Node | null]>;
25665 keys(): IterableIterator<number>;
25666 values(): IterableIterator<Node | null>;
25669 interface PaintRequestList {
25670 [Symbol.iterator](): IterableIterator<PaintRequest>;
25673 interface PeerConnectionObserver {
25674 fireTrackEvent(receiver: RTCRtpReceiver, streams: Iterable<MediaStream>): void;
25677 interface PlacesEventCounts extends ReadonlyMap<string, number> {
25681 [Symbol.iterator](): IterableIterator<MimeType>;
25684 interface PluginArray {
25685 [Symbol.iterator](): IterableIterator<Plugin>;
25688 interface RTCRtpTransceiver {
25689 setCodecPreferences(codecs: Iterable<RTCRtpCodec>): void;
25692 interface RTCStatsReport extends ReadonlyMap<string, any> {
25695 interface SVGLengthList {
25696 [Symbol.iterator](): IterableIterator<SVGLength>;
25699 interface SVGNumberList {
25700 [Symbol.iterator](): IterableIterator<SVGNumber>;
25703 interface SVGPathSegList {
25704 [Symbol.iterator](): IterableIterator<SVGPathSeg>;
25707 interface SVGPointList {
25708 [Symbol.iterator](): IterableIterator<SVGPoint>;
25711 interface SVGStringList {
25712 [Symbol.iterator](): IterableIterator<string>;
25715 interface SVGTransformList {
25716 [Symbol.iterator](): IterableIterator<SVGTransform>;
25720 mozLockOrientation(orientation: Iterable<string>): boolean;
25723 interface ServiceWorker {
25724 postMessage(message: any, transferable: Iterable<any>): void;
25727 interface SourceBufferList {
25728 [Symbol.iterator](): IterableIterator<SourceBuffer>;
25731 interface SpeechGrammarList {
25732 [Symbol.iterator](): IterableIterator<SpeechGrammar>;
25735 interface SpeechRecognitionResult {
25736 [Symbol.iterator](): IterableIterator<SpeechRecognitionAlternative>;
25739 interface SpeechRecognitionResultList {
25740 [Symbol.iterator](): IterableIterator<SpeechRecognitionResult>;
25743 interface StyleSheetList {
25744 [Symbol.iterator](): IterableIterator<CSSStyleSheet>;
25747 interface SubtleCrypto {
25748 deriveKey(algorithm: AlgorithmIdentifier, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<any>;
25749 generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<any>;
25750 importKey(format: KeyFormat, keyData: any, algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<any>;
25751 unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier, unwrappedKeyAlgorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<any>;
25754 interface TestInterfaceIterableDouble {
25755 [Symbol.iterator](): IterableIterator<[string, string]>;
25756 entries(): IterableIterator<[string, string]>;
25757 keys(): IterableIterator<string>;
25758 values(): IterableIterator<string>;
25761 interface TestInterfaceIterableDoubleUnion {
25762 [Symbol.iterator](): IterableIterator<[string, string | number]>;
25763 entries(): IterableIterator<[string, string | number]>;
25764 keys(): IterableIterator<string>;
25765 values(): IterableIterator<string | number>;
25768 interface TestInterfaceIterableSingle {
25769 [Symbol.iterator](): IterableIterator<number>;
25770 entries(): IterableIterator<[number, number]>;
25771 keys(): IterableIterator<number>;
25772 values(): IterableIterator<number>;
25775 interface TestInterfaceJS {
25776 anySequenceLength(seq: Iterable<any>): number;
25777 objectSequenceLength(seq: Iterable<any>): number;
25778 testSequenceOverload(arg: Iterable<string>): void;
25779 testSequenceUnion(arg: Iterable<string> | string): void;
25782 interface TestInterfaceMaplike extends Map<string, number> {
25785 interface TestInterfaceMaplikeJSObject extends ReadonlyMap<string, any> {
25788 interface TestInterfaceMaplikeObject extends ReadonlyMap<string, TestInterfaceMaplike> {
25791 interface TestInterfaceSetlike extends Set<string> {
25794 interface TestInterfaceSetlikeNode extends Set<Node> {
25797 interface TextTrackCueList {
25798 [Symbol.iterator](): IterableIterator<VTTCue>;
25801 interface TextTrackList {
25802 [Symbol.iterator](): IterableIterator<TextTrack>;
25805 interface TouchList {
25806 [Symbol.iterator](): IterableIterator<Touch>;
25809 interface TreeColumns {
25810 [Symbol.iterator](): IterableIterator<TreeColumn>;
25813 interface URLSearchParams {
25814 [Symbol.iterator](): IterableIterator<[string, string]>;
25815 entries(): IterableIterator<[string, string]>;
25816 keys(): IterableIterator<string>;
25817 values(): IterableIterator<string>;
25820 interface VRDisplay {
25821 requestPresent(layers: Iterable<VRLayer>): Promise<void>;
25824 interface VideoTrackList {
25825 [Symbol.iterator](): IterableIterator<VideoTrack>;
25828 interface WEBGL_draw_buffers {
25829 drawBuffersWEBGL(buffers: Iterable<GLenum>): void;
25832 interface WebGL2RenderingContextBase {
25833 clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Iterable<GLfloat>, srcOffset?: GLuint): void;
25834 clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Iterable<GLint>, srcOffset?: GLuint): void;
25835 clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Iterable<GLuint>, srcOffset?: GLuint): void;
25836 drawBuffers(buffers: Iterable<GLenum>): void;
25837 getActiveUniforms(program: WebGLProgram, uniformIndices: Iterable<GLuint>, pname: GLenum): any;
25838 getUniformIndices(program: WebGLProgram, uniformNames: Iterable<string>): Iterable<GLuint> | null;
25839 invalidateFramebuffer(target: GLenum, attachments: Iterable<GLenum>): void;
25840 invalidateSubFramebuffer(target: GLenum, attachments: Iterable<GLenum>, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
25841 transformFeedbackVaryings(program: WebGLProgram, varyings: Iterable<string>, bufferMode: GLenum): void;
25842 uniform1fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25843 uniform1iv(location: WebGLUniformLocation | null, data: Iterable<GLint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25844 uniform1uiv(location: WebGLUniformLocation | null, data: Iterable<GLuint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25845 uniform2fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25846 uniform2iv(location: WebGLUniformLocation | null, data: Iterable<GLint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25847 uniform2uiv(location: WebGLUniformLocation | null, data: Iterable<GLuint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25848 uniform3fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25849 uniform3iv(location: WebGLUniformLocation | null, data: Iterable<GLint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25850 uniform3uiv(location: WebGLUniformLocation | null, data: Iterable<GLuint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25851 uniform4fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25852 uniform4iv(location: WebGLUniformLocation | null, data: Iterable<GLint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25853 uniform4uiv(location: WebGLUniformLocation | null, data: Iterable<GLuint>, srcOffset?: GLuint, srcLength?: GLuint): void;
25854 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25855 uniformMatrix2x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25856 uniformMatrix2x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25857 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25858 uniformMatrix3x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25859 uniformMatrix3x4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25860 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25861 uniformMatrix4x2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25862 uniformMatrix4x3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>, srcOffset?: GLuint, srcLength?: GLuint): void;
25863 vertexAttribI4iv(index: GLuint, values: Iterable<GLint>): void;
25864 vertexAttribI4uiv(index: GLuint, values: Iterable<GLuint>): void;
25867 interface WebGLRenderingContext {
25868 uniform1fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>): void;
25869 uniform1iv(location: WebGLUniformLocation | null, data: Iterable<GLint>): void;
25870 uniform2fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>): void;
25871 uniform2iv(location: WebGLUniformLocation | null, data: Iterable<GLint>): void;
25872 uniform3fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>): void;
25873 uniform3iv(location: WebGLUniformLocation | null, data: Iterable<GLint>): void;
25874 uniform4fv(location: WebGLUniformLocation | null, data: Iterable<GLfloat>): void;
25875 uniform4iv(location: WebGLUniformLocation | null, data: Iterable<GLint>): void;
25876 uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>): void;
25877 uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>): void;
25878 uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, data: Iterable<GLfloat>): void;
25881 interface WebGLRenderingContextBase {
25882 vertexAttrib1fv(indx: GLuint, values: Iterable<GLfloat>): void;
25883 vertexAttrib2fv(indx: GLuint, values: Iterable<GLfloat>): void;
25884 vertexAttrib3fv(indx: GLuint, values: Iterable<GLfloat>): void;
25885 vertexAttrib4fv(indx: GLuint, values: Iterable<GLfloat>): void;
25888 interface WebSocket {
25889 createServerWebSocket(url: string, protocols: Iterable<string>, transportProvider: nsITransportProvider, negotiatedExtensions: string): WebSocket;
25893 postMessage(message: any, targetOrigin: string, transfer?: Iterable<any>): void;
25894 setScrollMarks(marks: Iterable<number>, onHorizontalScrollbar?: boolean): void;
25898 postMessage(message: any, transfer: Iterable<any>): void;
25901 interface XRInputSourceArray {
25902 [Symbol.iterator](): IterableIterator<XRInputSource>;
25903 entries(): IterableIterator<[number, XRInputSource]>;
25904 keys(): IterableIterator<number>;
25905 values(): IterableIterator<XRInputSource>;
25908 interface XSLTProcessor {
25909 setParameter(namespaceURI: string | null, localName: string, value: Iterable<Node>): void;
25912 /////////////////////////////
25913 /// Window Async Iterable APIs
25914 /////////////////////////////
25916 interface FileSystemDirectoryHandle {
25917 [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileSystemHandle]>;
25918 entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
25919 keys(): AsyncIterableIterator<string>;
25920 values(): AsyncIterableIterator<FileSystemHandle>;
25923 interface ReadableStream {
25924 [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): AsyncIterableIterator<any>;
25925 values(options?: ReadableStreamIteratorOptions): AsyncIterableIterator<any>;
25928 interface TestInterfaceAsyncIterableDouble {
25929 [Symbol.asyncIterator](): AsyncIterableIterator<[string, string]>;
25930 entries(): AsyncIterableIterator<[string, string]>;
25931 keys(): AsyncIterableIterator<string>;
25932 values(): AsyncIterableIterator<string>;
25935 interface TestInterfaceAsyncIterableDoubleUnion {
25936 [Symbol.asyncIterator](): AsyncIterableIterator<[string, string | number]>;
25937 entries(): AsyncIterableIterator<[string, string | number]>;
25938 keys(): AsyncIterableIterator<string>;
25939 values(): AsyncIterableIterator<string | number>;
25942 interface TestInterfaceAsyncIterableSingle {
25943 [Symbol.asyncIterator](): AsyncIterableIterator<number>;
25944 values(): AsyncIterableIterator<number>;
25947 interface TestInterfaceAsyncIterableSingleWithArgs {
25948 [Symbol.asyncIterator](options?: TestInterfaceAsyncIteratorOptions): AsyncIterableIterator<number>;
25949 values(options?: TestInterfaceAsyncIteratorOptions): AsyncIterableIterator<number>;