Pinsave/counterstrike
1
1/*! *****************************************************************************2Copyright (c) Microsoft Corporation. All rights reserved.3Licensed under the Apache License, Version 2.0 (the "License"); you may not use4this file except in compliance with the License. You may obtain a copy of the5License at http://www.apache.org/licenses/LICENSE-2.06 7THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY8KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED9WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,10MERCHANTABLITY OR NON-INFRINGEMENT.11 12See the Apache Version 2.0 License for specific language governing permissions13and limitations under the License.14***************************************************************************** */15 16 17/// <reference no-default-lib="true"/>18 19/////////////////////////////20/// Worker APIs21/////////////////////////////22 23interface AddEventListenerOptions extends EventListenerOptions {24 once?: boolean;25 passive?: boolean;26 signal?: AbortSignal;27}28 29interface AesCbcParams extends Algorithm {30 iv: BufferSource;31}32 33interface AesCtrParams extends Algorithm {34 counter: BufferSource;35 length: number;36}37 38interface AesDerivedKeyParams extends Algorithm {39 length: number;40}41 42interface AesGcmParams extends Algorithm {43 additionalData?: BufferSource;44 iv: BufferSource;45 tagLength?: number;46}47 48interface AesKeyAlgorithm extends KeyAlgorithm {49 length: number;50}51 52interface AesKeyGenParams extends Algorithm {53 length: number;54}55 56interface Algorithm {57 name: string;58}59 60interface AudioConfiguration {61 bitrate?: number;62 channels?: string;63 contentType: string;64 samplerate?: number;65 spatialRendering?: boolean;66}67 68interface AudioDataCopyToOptions {69 format?: AudioSampleFormat;70 frameCount?: number;71 frameOffset?: number;72 planeIndex: number;73}74 75interface AudioDataInit {76 data: BufferSource;77 format: AudioSampleFormat;78 numberOfChannels: number;79 numberOfFrames: number;80 sampleRate: number;81 timestamp: number;82 transfer?: ArrayBuffer[];83}84 85interface AudioDecoderConfig {86 codec: string;87 description?: AllowSharedBufferSource;88 numberOfChannels: number;89 sampleRate: number;90}91 92interface AudioDecoderInit {93 error: WebCodecsErrorCallback;94 output: AudioDataOutputCallback;95}96 97interface AudioDecoderSupport {98 config?: AudioDecoderConfig;99 supported?: boolean;100}101 102interface AudioEncoderConfig {103 bitrate?: number;104 bitrateMode?: BitrateMode;105 codec: string;106 numberOfChannels: number;107 opus?: OpusEncoderConfig;108 sampleRate: number;109}110 111interface AudioEncoderInit {112 error: WebCodecsErrorCallback;113 output: EncodedAudioChunkOutputCallback;114}115 116interface AudioEncoderSupport {117 config?: AudioEncoderConfig;118 supported?: boolean;119}120 121interface AvcEncoderConfig {122 format?: AvcBitstreamFormat;123}124 125interface BlobPropertyBag {126 endings?: EndingType;127 type?: string;128}129 130interface CSSMatrixComponentOptions {131 is2D?: boolean;132}133 134interface CSSNumericType {135 angle?: number;136 flex?: number;137 frequency?: number;138 length?: number;139 percent?: number;140 percentHint?: CSSNumericBaseType;141 resolution?: number;142 time?: number;143}144 145interface CacheQueryOptions {146 ignoreMethod?: boolean;147 ignoreSearch?: boolean;148 ignoreVary?: boolean;149}150 151interface ClientQueryOptions {152 includeUncontrolled?: boolean;153 type?: ClientTypes;154}155 156interface CloseEventInit extends EventInit {157 code?: number;158 reason?: string;159 wasClean?: boolean;160}161 162interface CookieInit {163 domain?: string | null;164 expires?: DOMHighResTimeStamp | null;165 name: string;166 partitioned?: boolean;167 path?: string;168 sameSite?: CookieSameSite;169 value: string;170}171 172interface CookieListItem {173 name?: string;174 value?: string;175}176 177interface CookieStoreDeleteOptions {178 domain?: string | null;179 name: string;180 partitioned?: boolean;181 path?: string;182}183 184interface CookieStoreGetOptions {185 name?: string;186 url?: string;187}188 189interface CryptoKeyPair {190 privateKey: CryptoKey;191 publicKey: CryptoKey;192}193 194interface CustomEventInit<T = any> extends EventInit {195 detail?: T;196}197 198interface DOMMatrix2DInit {199 a?: number;200 b?: number;201 c?: number;202 d?: number;203 e?: number;204 f?: number;205 m11?: number;206 m12?: number;207 m21?: number;208 m22?: number;209 m41?: number;210 m42?: number;211}212 213interface DOMMatrixInit extends DOMMatrix2DInit {214 is2D?: boolean;215 m13?: number;216 m14?: number;217 m23?: number;218 m24?: number;219 m31?: number;220 m32?: number;221 m33?: number;222 m34?: number;223 m43?: number;224 m44?: number;225}226 227interface DOMPointInit {228 w?: number;229 x?: number;230 y?: number;231 z?: number;232}233 234interface DOMQuadInit {235 p1?: DOMPointInit;236 p2?: DOMPointInit;237 p3?: DOMPointInit;238 p4?: DOMPointInit;239}240 241interface DOMRectInit {242 height?: number;243 width?: number;244 x?: number;245 y?: number;246}247 248interface EcKeyGenParams extends Algorithm {249 namedCurve: NamedCurve;250}251 252interface EcKeyImportParams extends Algorithm {253 namedCurve: NamedCurve;254}255 256interface EcdhKeyDeriveParams extends Algorithm {257 public: CryptoKey;258}259 260interface EcdsaParams extends Algorithm {261 hash: HashAlgorithmIdentifier;262}263 264interface EncodedAudioChunkInit {265 data: AllowSharedBufferSource;266 duration?: number;267 timestamp: number;268 transfer?: ArrayBuffer[];269 type: EncodedAudioChunkType;270}271 272interface EncodedAudioChunkMetadata {273 decoderConfig?: AudioDecoderConfig;274}275 276interface EncodedVideoChunkInit {277 data: AllowSharedBufferSource;278 duration?: number;279 timestamp: number;280 type: EncodedVideoChunkType;281}282 283interface EncodedVideoChunkMetadata {284 decoderConfig?: VideoDecoderConfig;285}286 287interface ErrorEventInit extends EventInit {288 colno?: number;289 error?: any;290 filename?: string;291 lineno?: number;292 message?: string;293}294 295interface EventInit {296 bubbles?: boolean;297 cancelable?: boolean;298 composed?: boolean;299}300 301interface EventListenerOptions {302 capture?: boolean;303}304 305interface EventSourceInit {306 withCredentials?: boolean;307}308 309interface ExtendableCookieChangeEventInit extends ExtendableEventInit {310 changed?: CookieList;311 deleted?: CookieList;312}313 314interface ExtendableEventInit extends EventInit {315}316 317interface ExtendableMessageEventInit extends ExtendableEventInit {318 data?: any;319 lastEventId?: string;320 origin?: string;321 ports?: MessagePort[];322 source?: Client | ServiceWorker | MessagePort | null;323}324 325interface FetchEventInit extends ExtendableEventInit {326 clientId?: string;327 handled?: Promise<void>;328 preloadResponse?: Promise<any>;329 request: Request;330 resultingClientId?: string;331}332 333interface FilePropertyBag extends BlobPropertyBag {334 lastModified?: number;335}336 337interface FileSystemCreateWritableOptions {338 keepExistingData?: boolean;339}340 341interface FileSystemGetDirectoryOptions {342 create?: boolean;343}344 345interface FileSystemGetFileOptions {346 create?: boolean;347}348 349interface FileSystemReadWriteOptions {350 at?: number;351}352 353interface FileSystemRemoveOptions {354 recursive?: boolean;355}356 357interface FontFaceDescriptors {358 ascentOverride?: string;359 descentOverride?: string;360 display?: FontDisplay;361 featureSettings?: string;362 lineGapOverride?: string;363 stretch?: string;364 style?: string;365 unicodeRange?: string;366 weight?: string;367}368 369interface FontFaceSetLoadEventInit extends EventInit {370 fontfaces?: FontFace[];371}372 373interface GetNotificationOptions {374 tag?: string;375}376 377interface HkdfParams extends Algorithm {378 hash: HashAlgorithmIdentifier;379 info: BufferSource;380 salt: BufferSource;381}382 383interface HmacImportParams extends Algorithm {384 hash: HashAlgorithmIdentifier;385 length?: number;386}387 388interface HmacKeyGenParams extends Algorithm {389 hash: HashAlgorithmIdentifier;390 length?: number;391}392 393interface IDBDatabaseInfo {394 name?: string;395 version?: number;396}397 398interface IDBIndexParameters {399 multiEntry?: boolean;400 unique?: boolean;401}402 403interface IDBObjectStoreParameters {404 autoIncrement?: boolean;405 keyPath?: string | string[] | null;406}407 408interface IDBTransactionOptions {409 durability?: IDBTransactionDurability;410}411 412interface IDBVersionChangeEventInit extends EventInit {413 newVersion?: number | null;414 oldVersion?: number;415}416 417interface ImageBitmapOptions {418 colorSpaceConversion?: ColorSpaceConversion;419 imageOrientation?: ImageOrientation;420 premultiplyAlpha?: PremultiplyAlpha;421 resizeHeight?: number;422 resizeQuality?: ResizeQuality;423 resizeWidth?: number;424}425 426interface ImageBitmapRenderingContextSettings {427 alpha?: boolean;428}429 430interface ImageDataSettings {431 colorSpace?: PredefinedColorSpace;432}433 434interface ImageDecodeOptions {435 completeFramesOnly?: boolean;436 frameIndex?: number;437}438 439interface ImageDecodeResult {440 complete: boolean;441 image: VideoFrame;442}443 444interface ImageDecoderInit {445 colorSpaceConversion?: ColorSpaceConversion;446 data: ImageBufferSource;447 desiredHeight?: number;448 desiredWidth?: number;449 preferAnimation?: boolean;450 transfer?: ArrayBuffer[];451 type: string;452}453 454interface ImageEncodeOptions {455 quality?: number;456 type?: string;457}458 459interface JsonWebKey {460 alg?: string;461 crv?: string;462 d?: string;463 dp?: string;464 dq?: string;465 e?: string;466 ext?: boolean;467 k?: string;468 key_ops?: string[];469 kty?: string;470 n?: string;471 oth?: RsaOtherPrimesInfo[];472 p?: string;473 q?: string;474 qi?: string;475 use?: string;476 x?: string;477 y?: string;478}479 480interface KeyAlgorithm {481 name: string;482}483 484interface KeySystemTrackConfiguration {485 robustness?: string;486}487 488interface LockInfo {489 clientId?: string;490 mode?: LockMode;491 name?: string;492}493 494interface LockManagerSnapshot {495 held?: LockInfo[];496 pending?: LockInfo[];497}498 499interface LockOptions {500 ifAvailable?: boolean;501 mode?: LockMode;502 signal?: AbortSignal;503 steal?: boolean;504}505 506interface MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {507}508 509interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {510}511 512interface MediaCapabilitiesInfo {513 powerEfficient: boolean;514 smooth: boolean;515 supported: boolean;516}517 518interface MediaCapabilitiesKeySystemConfiguration {519 audio?: KeySystemTrackConfiguration;520 distinctiveIdentifier?: MediaKeysRequirement;521 initDataType?: string;522 keySystem: string;523 persistentState?: MediaKeysRequirement;524 sessionTypes?: string[];525 video?: KeySystemTrackConfiguration;526}527 528interface MediaConfiguration {529 audio?: AudioConfiguration;530 video?: VideoConfiguration;531}532 533interface MediaDecodingConfiguration extends MediaConfiguration {534 keySystemConfiguration?: MediaCapabilitiesKeySystemConfiguration;535 type: MediaDecodingType;536}537 538interface MediaEncodingConfiguration extends MediaConfiguration {539 type: MediaEncodingType;540}541 542interface MediaStreamTrackProcessorInit {543 maxBufferSize?: number;544}545 546interface MessageEventInit<T = any> extends EventInit {547 data?: T;548 lastEventId?: string;549 origin?: string;550 ports?: MessagePort[];551 source?: MessageEventSource | null;552}553 554interface MultiCacheQueryOptions extends CacheQueryOptions {555 cacheName?: string;556}557 558interface NavigationPreloadState {559 enabled?: boolean;560 headerValue?: string;561}562 563interface NotificationEventInit extends ExtendableEventInit {564 action?: string;565 notification: Notification;566}567 568interface NotificationOptions {569 badge?: string;570 body?: string;571 data?: any;572 dir?: NotificationDirection;573 icon?: string;574 lang?: string;575 requireInteraction?: boolean;576 silent?: boolean | null;577 tag?: string;578}579 580interface OpusEncoderConfig {581 complexity?: number;582 format?: OpusBitstreamFormat;583 frameDuration?: number;584 packetlossperc?: number;585 usedtx?: boolean;586 useinbandfec?: boolean;587}588 589interface Pbkdf2Params extends Algorithm {590 hash: HashAlgorithmIdentifier;591 iterations: number;592 salt: BufferSource;593}594 595interface PerformanceMarkOptions {596 detail?: any;597 startTime?: DOMHighResTimeStamp;598}599 600interface PerformanceMeasureOptions {601 detail?: any;602 duration?: DOMHighResTimeStamp;603 end?: string | DOMHighResTimeStamp;604 start?: string | DOMHighResTimeStamp;605}606 607interface PerformanceObserverInit {608 buffered?: boolean;609 entryTypes?: string[];610 type?: string;611}612 613interface PermissionDescriptor {614 name: PermissionName;615}616 617interface PlaneLayout {618 offset: number;619 stride: number;620}621 622interface ProgressEventInit extends EventInit {623 lengthComputable?: boolean;624 loaded?: number;625 total?: number;626}627 628interface PromiseRejectionEventInit extends EventInit {629 promise: Promise<any>;630 reason?: any;631}632 633interface PushEventInit extends ExtendableEventInit {634 data?: PushMessageDataInit;635}636 637interface PushSubscriptionChangeEventInit extends ExtendableEventInit {638 newSubscription?: PushSubscription;639 oldSubscription?: PushSubscription;640}641 642interface PushSubscriptionJSON {643 endpoint?: string;644 expirationTime?: EpochTimeStamp | null;645 keys?: Record<string, string>;646}647 648interface PushSubscriptionOptionsInit {649 applicationServerKey?: BufferSource | string | null;650 userVisibleOnly?: boolean;651}652 653interface QueuingStrategy<T = any> {654 highWaterMark?: number;655 size?: QueuingStrategySize<T>;656}657 658interface QueuingStrategyInit {659 /**660 * Creates a new ByteLengthQueuingStrategy with the provided high water mark.661 *662 * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.663 */664 highWaterMark: number;665}666 667interface RTCEncodedAudioFrameMetadata extends RTCEncodedFrameMetadata {668 sequenceNumber?: number;669}670 671interface RTCEncodedFrameMetadata {672 contributingSources?: number[];673 mimeType?: string;674 payloadType?: number;675 rtpTimestamp?: number;676 synchronizationSource?: number;677}678 679interface RTCEncodedVideoFrameMetadata extends RTCEncodedFrameMetadata {680 dependencies?: number[];681 frameId?: number;682 height?: number;683 spatialIndex?: number;684 temporalIndex?: number;685 timestamp?: number;686 width?: number;687}688 689interface ReadableStreamGetReaderOptions {690 /**691 * Creates a ReadableStreamBYOBReader and locks the stream to the new reader.692 *693 * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.694 */695 mode?: ReadableStreamReaderMode;696}697 698interface ReadableStreamIteratorOptions {699 /**700 * Asynchronously iterates over the chunks in the stream's internal queue.701 *702 * Asynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader. The lock will be released if the async iterator's return() method is called, e.g. by breaking out of the loop.703 *704 * By default, calling the async iterator's return() method will also cancel the stream. To prevent this, use the stream's values() method, passing true for the preventCancel option.705 */706 preventCancel?: boolean;707}708 709interface ReadableStreamReadDoneResult<T> {710 done: true;711 value: T | undefined;712}713 714interface ReadableStreamReadValueResult<T> {715 done: false;716 value: T;717}718 719interface ReadableWritablePair<R = any, W = any> {720 readable: ReadableStream<R>;721 /**722 * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.723 *724 * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.725 */726 writable: WritableStream<W>;727}728 729interface RegistrationOptions {730 scope?: string;731 type?: WorkerType;732 updateViaCache?: ServiceWorkerUpdateViaCache;733}734 735interface ReportingObserverOptions {736 buffered?: boolean;737 types?: string[];738}739 740interface RequestInit {741 /** A BodyInit object or null to set request's body. */742 body?: BodyInit | null;743 /** A string indicating how the request will interact with the browser's cache to set request's cache. */744 cache?: RequestCache;745 /** A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. */746 credentials?: RequestCredentials;747 /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */748 headers?: HeadersInit;749 /** A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */750 integrity?: string;751 /** A boolean to set request's keepalive. */752 keepalive?: boolean;753 /** A string to set request's method. */754 method?: string;755 /** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */756 mode?: RequestMode;757 priority?: RequestPriority;758 /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */759 redirect?: RequestRedirect;760 /** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */761 referrer?: string;762 /** A referrer policy to set request's referrerPolicy. */763 referrerPolicy?: ReferrerPolicy;764 /** An AbortSignal to set request's signal. */765 signal?: AbortSignal | null;766 /** Can only be null. Used to disassociate request from any Window. */767 window?: null;768}769 770interface ResponseInit {771 headers?: HeadersInit;772 status?: number;773 statusText?: string;774}775 776interface RsaHashedImportParams extends Algorithm {777 hash: HashAlgorithmIdentifier;778}779 780interface RsaHashedKeyGenParams extends RsaKeyGenParams {781 hash: HashAlgorithmIdentifier;782}783 784interface RsaKeyGenParams extends Algorithm {785 modulusLength: number;786 publicExponent: BigInteger;787}788 789interface RsaOaepParams extends Algorithm {790 label?: BufferSource;791}792 793interface RsaOtherPrimesInfo {794 d?: string;795 r?: string;796 t?: string;797}798 799interface RsaPssParams extends Algorithm {800 saltLength: number;801}802 803interface SecurityPolicyViolationEventInit extends EventInit {804 blockedURI?: string;805 columnNumber?: number;806 disposition?: SecurityPolicyViolationEventDisposition;807 documentURI?: string;808 effectiveDirective?: string;809 lineNumber?: number;810 originalPolicy?: string;811 referrer?: string;812 sample?: string;813 sourceFile?: string;814 statusCode?: number;815 violatedDirective?: string;816}817 818interface StorageEstimate {819 quota?: number;820 usage?: number;821}822 823interface StreamPipeOptions {824 preventAbort?: boolean;825 preventCancel?: boolean;826 /**827 * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.828 *829 * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.830 *831 * Errors and closures of the source and destination streams propagate as follows:832 *833 * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.834 *835 * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.836 *837 * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.838 *839 * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.840 *841 * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.842 */843 preventClose?: boolean;844 signal?: AbortSignal;845}846 847interface StructuredSerializeOptions {848 transfer?: Transferable[];849}850 851interface TextDecodeOptions {852 stream?: boolean;853}854 855interface TextDecoderOptions {856 fatal?: boolean;857 ignoreBOM?: boolean;858}859 860interface TextEncoderEncodeIntoResult {861 read: number;862 written: number;863}864 865interface Transformer<I = any, O = any> {866 flush?: TransformerFlushCallback<O>;867 readableType?: undefined;868 start?: TransformerStartCallback<O>;869 transform?: TransformerTransformCallback<I, O>;870 writableType?: undefined;871}872 873interface UnderlyingByteSource {874 autoAllocateChunkSize?: number;875 cancel?: UnderlyingSourceCancelCallback;876 pull?: (controller: ReadableByteStreamController) => void | PromiseLike<void>;877 start?: (controller: ReadableByteStreamController) => any;878 type: "bytes";879}880 881interface UnderlyingDefaultSource<R = any> {882 cancel?: UnderlyingSourceCancelCallback;883 pull?: (controller: ReadableStreamDefaultController<R>) => void | PromiseLike<void>;884 start?: (controller: ReadableStreamDefaultController<R>) => any;885 type?: undefined;886}887 888interface UnderlyingSink<W = any> {889 abort?: UnderlyingSinkAbortCallback;890 close?: UnderlyingSinkCloseCallback;891 start?: UnderlyingSinkStartCallback;892 type?: undefined;893 write?: UnderlyingSinkWriteCallback<W>;894}895 896interface UnderlyingSource<R = any> {897 autoAllocateChunkSize?: number;898 cancel?: UnderlyingSourceCancelCallback;899 pull?: UnderlyingSourcePullCallback<R>;900 start?: UnderlyingSourceStartCallback<R>;901 type?: ReadableStreamType;902}903 904interface VideoColorSpaceInit {905 fullRange?: boolean | null;906 matrix?: VideoMatrixCoefficients | null;907 primaries?: VideoColorPrimaries | null;908 transfer?: VideoTransferCharacteristics | null;909}910 911interface VideoConfiguration {912 bitrate: number;913 colorGamut?: ColorGamut;914 contentType: string;915 framerate: number;916 hasAlphaChannel?: boolean;917 hdrMetadataType?: HdrMetadataType;918 height: number;919 scalabilityMode?: string;920 transferFunction?: TransferFunction;921 width: number;922}923 924interface VideoDecoderConfig {925 codec: string;926 codedHeight?: number;927 codedWidth?: number;928 colorSpace?: VideoColorSpaceInit;929 description?: AllowSharedBufferSource;930 displayAspectHeight?: number;931 displayAspectWidth?: number;932 hardwareAcceleration?: HardwareAcceleration;933 optimizeForLatency?: boolean;934}935 936interface VideoDecoderInit {937 error: WebCodecsErrorCallback;938 output: VideoFrameOutputCallback;939}940 941interface VideoDecoderSupport {942 config?: VideoDecoderConfig;943 supported?: boolean;944}945 946interface VideoEncoderConfig {947 alpha?: AlphaOption;948 avc?: AvcEncoderConfig;949 bitrate?: number;950 bitrateMode?: VideoEncoderBitrateMode;951 codec: string;952 contentHint?: string;953 displayHeight?: number;954 displayWidth?: number;955 framerate?: number;956 hardwareAcceleration?: HardwareAcceleration;957 height: number;958 latencyMode?: LatencyMode;959 scalabilityMode?: string;960 width: number;961}962 963interface VideoEncoderEncodeOptions {964 avc?: VideoEncoderEncodeOptionsForAvc;965 keyFrame?: boolean;966}967 968interface VideoEncoderEncodeOptionsForAvc {969 quantizer?: number | null;970}971 972interface VideoEncoderInit {973 error: WebCodecsErrorCallback;974 output: EncodedVideoChunkOutputCallback;975}976 977interface VideoEncoderSupport {978 config?: VideoEncoderConfig;979 supported?: boolean;980}981 982interface VideoFrameBufferInit {983 codedHeight: number;984 codedWidth: number;985 colorSpace?: VideoColorSpaceInit;986 displayHeight?: number;987 displayWidth?: number;988 duration?: number;989 format: VideoPixelFormat;990 layout?: PlaneLayout[];991 timestamp: number;992 visibleRect?: DOMRectInit;993}994 995interface VideoFrameCopyToOptions {996 colorSpace?: PredefinedColorSpace;997 format?: VideoPixelFormat;998 layout?: PlaneLayout[];999 rect?: DOMRectInit;1000}1001 1002interface VideoFrameInit {1003 alpha?: AlphaOption;1004 displayHeight?: number;1005 displayWidth?: number;1006 duration?: number;1007 timestamp?: number;1008 visibleRect?: DOMRectInit;1009}1010 1011interface WebGLContextAttributes {1012 alpha?: boolean;1013 antialias?: boolean;1014 depth?: boolean;1015 desynchronized?: boolean;1016 failIfMajorPerformanceCaveat?: boolean;1017 powerPreference?: WebGLPowerPreference;1018 premultipliedAlpha?: boolean;1019 preserveDrawingBuffer?: boolean;1020 stencil?: boolean;1021}1022 1023interface WebGLContextEventInit extends EventInit {1024 statusMessage?: string;1025}1026 1027interface WebTransportCloseInfo {1028 closeCode?: number;1029 reason?: string;1030}1031 1032interface WebTransportErrorOptions {1033 source?: WebTransportErrorSource;1034 streamErrorCode?: number | null;1035}1036 1037interface WebTransportHash {1038 algorithm?: string;1039 value?: BufferSource;1040}1041 1042interface WebTransportOptions {1043 allowPooling?: boolean;1044 congestionControl?: WebTransportCongestionControl;1045 requireUnreliable?: boolean;1046 serverCertificateHashes?: WebTransportHash[];1047}1048 1049interface WebTransportSendOptions {1050 sendOrder?: number;1051}1052 1053interface WebTransportSendStreamOptions extends WebTransportSendOptions {1054}1055 1056interface WorkerOptions {1057 credentials?: RequestCredentials;1058 name?: string;1059 type?: WorkerType;1060}1061 1062interface WriteParams {1063 data?: BufferSource | Blob | string | null;1064 position?: number | null;1065 size?: number | null;1066 type: WriteCommandType;1067}1068 1069/**1070 * The **`ANGLE_instanced_arrays`** extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type.1071 *1072 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays)1073 */1074interface ANGLE_instanced_arrays {1075 /**1076 * The **`ANGLE_instanced_arrays.drawArraysInstancedANGLE()`** method of the WebGL API renders primitives from array data like the WebGLRenderingContext.drawArrays() method.1077 *1078 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawArraysInstancedANGLE)1079 */1080 drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;1081 /**1082 * The **`ANGLE_instanced_arrays.drawElementsInstancedANGLE()`** method of the WebGL API renders primitives from array data like the WebGLRenderingContext.drawElements() method.1083 *1084 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/drawElementsInstancedANGLE)1085 */1086 drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;1087 /**1088 * The **ANGLE_instanced_arrays.vertexAttribDivisorANGLE()** method of the WebGL API modifies the rate at which generic vertex attributes advance when rendering multiple instances of primitives with ANGLE_instanced_arrays.drawArraysInstancedANGLE() and ANGLE_instanced_arrays.drawElementsInstancedANGLE().1089 *1090 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ANGLE_instanced_arrays/vertexAttribDivisorANGLE)1091 */1092 vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;1093 readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: 0x88FE;1094}1095 1096/**1097 * The **`AbortController`** interface represents a controller object that allows you to abort one or more Web requests as and when desired.1098 *1099 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController)1100 */1101interface AbortController {1102 /**1103 * The **`signal`** read-only property of the AbortController interface returns an AbortSignal object instance, which can be used to communicate with/abort an asynchronous operation as desired.1104 *1105 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/signal)1106 */1107 readonly signal: AbortSignal;1108 /**1109 * The **`abort()`** method of the AbortController interface aborts an asynchronous operation before it has completed.1110 *1111 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)1112 */1113 abort(reason?: any): void;1114}1115 1116declare var AbortController: {1117 prototype: AbortController;1118 new(): AbortController;1119};1120 1121interface AbortSignalEventMap {1122 "abort": Event;1123}1124 1125/**1126 * The **`AbortSignal`** interface represents a signal object that allows you to communicate with an asynchronous operation (such as a fetch request) and abort it if required via an AbortController object.1127 *1128 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal)1129 */1130interface AbortSignal extends EventTarget {1131 /**1132 * The **`aborted`** read-only property returns a value that indicates whether the asynchronous operations the signal is communicating with are aborted (`true`) or not (`false`).1133 *1134 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted)1135 */1136 readonly aborted: boolean;1137 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_event) */1138 onabort: ((this: AbortSignal, ev: Event) => any) | null;1139 /**1140 * The **`reason`** read-only property returns a JavaScript value that indicates the abort reason.1141 *1142 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason)1143 */1144 readonly reason: any;1145 /**1146 * The **`throwIfAborted()`** method throws the signal's abort AbortSignal.reason if the signal has been aborted; otherwise it does nothing.1147 *1148 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted)1149 */1150 throwIfAborted(): void;1151 addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;1152 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;1153 removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;1154 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;1155}1156 1157declare var AbortSignal: {1158 prototype: AbortSignal;1159 new(): AbortSignal;1160 /**1161 * The **`AbortSignal.abort()`** static method returns an AbortSignal that is already set as aborted (and which does not trigger an AbortSignal/abort_event event).1162 *1163 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static)1164 */1165 abort(reason?: any): AbortSignal;1166 /**1167 * The **`AbortSignal.any()`** static method takes an iterable of abort signals and returns an AbortSignal.1168 *1169 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/any_static)1170 */1171 any(signals: AbortSignal[]): AbortSignal;1172 /**1173 * The **`AbortSignal.timeout()`** static method returns an AbortSignal that will automatically abort after a specified time.1174 *1175 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static)1176 */1177 timeout(milliseconds: number): AbortSignal;1178};1179 1180interface AbstractWorkerEventMap {1181 "error": ErrorEvent;1182}1183 1184interface AbstractWorker {1185 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorker/error_event) */1186 onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;1187 addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;1188 addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;1189 removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;1190 removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;1191}1192 1193interface AnimationFrameProvider {1194 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */1195 cancelAnimationFrame(handle: number): void;1196 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */1197 requestAnimationFrame(callback: FrameRequestCallback): number;1198}1199 1200/**