@samitouri / QOS-React / commits / 6de32a5a07

Update Flow to 0.263 (#34269)

This update was a bit more involved. - `React$Component` was removed, I replaced it with Flow component types. - Flow removed shipping the standard library. This adds the environment libraries back from `flow-typed` which seemed to have changed slightly (probably got more precise and less `any`s). Suppresses some new type errors.

Jan Kassens committed Aug 22, 2025 at 12:10 UTC 6de32a5a07958d7fc2f8d0785f5873d2da73b9fa
43 files changed +14129 -90
.eslintignore
+3
@@ -28,3 +28,6 @@ packages/react-devtools-shared/src/hooks/__tests__/__source__/__untransformed__/
28 packages/react-devtools-shell/dist
29 packages/react-devtools-timeline/dist
30 packages/react-devtools-timeline/static
31 +
32 +# Imported third-party Flow types
33 +flow-typed/
.eslintrc.js
+1 -1
@@ -581,6 +581,7 @@ module.exports = {
581 IteratorResult: 'readonly',
582 JSONValue: 'readonly',
583 JSResourceReference: 'readonly',
584 + mixin$Animatable: 'readonly',
585 MouseEventHandler: 'readonly',
586 NavigateEvent: 'readonly',
587 PropagationPhases: 'readonly',
@@ -619,7 +620,6 @@ module.exports = {
620 PropertyIndexedKeyframes: 'readonly',
621 KeyframeAnimationOptions: 'readonly',
622 GetAnimationsOptions: 'readonly',
622 - Animatable: 'readonly',
623 ScrollTimeline: 'readonly',
624 EventListenerOptionsOrUseCapture: 'readonly',
625 FocusOptions: 'readonly',
flow-typed.config.json new
+20
@@ -0,0 +1,20 @@
1 +{
2 + "env": [
3 + "bom",
4 + "cssom",
5 + "dom",
6 + "geometry",
7 + "html",
8 + "node",
9 + "serviceworkers",
10 + "streams",
11 + "web-animations"
12 + ],
13 + "ignore": [
14 + "create-react-class",
15 + "jest",
16 + "regenerator-runtime",
17 + "webpack",
18 + "ws"
19 + ]
20 +}
flow-typed/environments/bom.js new
+2719
@@ -0,0 +1,2719 @@
1 +// flow-typed signature: 09630545c584c3b212588a2390c257d0
2 +// flow-typed version: baae4b8bcc/bom/flow_>=v0.261.x
3 +
4 +/* BOM */
5 +
6 +declare class Screen {
7 + +availHeight: number;
8 + +availWidth: number;
9 + +availLeft: number;
10 + +availTop: number;
11 + +top: number;
12 + +left: number;
13 + +colorDepth: number;
14 + +pixelDepth: number;
15 + +width: number;
16 + +height: number;
17 + +orientation?: {
18 + lock(): Promise<void>,
19 + unlock(): void,
20 + angle: number,
21 + onchange: () => mixed,
22 + type:
23 + | 'portrait-primary'
24 + | 'portrait-secondary'
25 + | 'landscape-primary'
26 + | 'landscape-secondary',
27 + ...
28 + };
29 + // deprecated
30 + mozLockOrientation?: (orientation: string | Array<string>) => boolean;
31 + mozUnlockOrientation?: () => void;
32 + mozOrientation?: string;
33 + onmozorientationchange?: (...args: any[]) => mixed;
34 +}
35 +
36 +declare var screen: Screen;
37 +
38 +declare interface Crypto {
39 + // Not using $TypedArray as that would include Float32Array and Float64Array which are not accepted
40 + getRandomValues: <
41 + T:
42 + | Int8Array
43 + | Uint8Array
44 + | Uint8ClampedArray
45 + | Int16Array
46 + | Uint16Array
47 + | Int32Array
48 + | Uint32Array
49 + | BigInt64Array
50 + | BigUint64Array,
51 + >(
52 + typedArray: T
53 + ) => T;
54 + randomUUID: () => string;
55 +}
56 +declare var crypto: Crypto;
57 +
58 +declare var window: any;
59 +
60 +type GamepadButton = {
61 + pressed: boolean,
62 + value: number,
63 + ...
64 +};
65 +type GamepadHapticActuator = {
66 + type: 'vibration',
67 + pulse(value: number, duration: number): Promise<boolean>,
68 + ...
69 +};
70 +type GamepadPose = {
71 + angularAcceleration: null | Float32Array,
72 + angularVelocity: null | Float32Array,
73 + hasOrientation: boolean,
74 + hasPosition: boolean,
75 + linearAcceleration: null | Float32Array,
76 + linearVelocity: null | Float32Array,
77 + orientation: null | Float32Array,
78 + position: null | Float32Array,
79 + ...
80 +};
81 +type Gamepad = {
82 + axes: number[],
83 + buttons: GamepadButton[],
84 + connected: boolean,
85 + displayId?: number,
86 + hapticActuators?: GamepadHapticActuator[],
87 + hand?: '' | 'left' | 'right',
88 + id: string,
89 + index: number,
90 + mapping: string,
91 + pose?: null | GamepadPose,
92 + timestamp: number,
93 + ...
94 +};
95 +
96 +// deprecated
97 +type BatteryManager = {
98 + +charging: boolean,
99 + +chargingTime: number,
100 + +dischargingTime: number,
101 + +level: number,
102 + onchargingchange: ?(event: any) => mixed,
103 + onchargingtimechange: ?(event: any) => mixed,
104 + ondischargingtimechange: ?(event: any) => mixed,
105 + onlevelchange: ?(event: any) => mixed,
106 + ...
107 +};
108 +
109 +// https://wicg.github.io/web-share
110 +type ShareData = {
111 + title?: string,
112 + text?: string,
113 + url?: string,
114 + ...
115 +};
116 +
117 +type PermissionName =
118 + | 'geolocation'
119 + | 'notifications'
120 + | 'push'
121 + | 'midi'
122 + | 'camera'
123 + | 'microphone'
124 + | 'speaker'
125 + | 'usb'
126 + | 'device-info'
127 + | 'background-sync'
128 + | 'bluetooth'
129 + | 'persistent-storage'
130 + | 'ambient-light-sensor'
131 + | 'accelerometer'
132 + | 'gyroscope'
133 + | 'magnetometer'
134 + | 'clipboard-read'
135 + | 'clipboard-write';
136 +
137 +type PermissionState = 'granted' | 'denied' | 'prompt';
138 +
139 +type PermissionDescriptor = {|
140 + name: PermissionName,
141 +|};
142 +
143 +type DevicePermissionDescriptor = {|
144 + deviceId?: string,
145 + name: 'camera' | 'microphone' | 'speaker',
146 +|};
147 +
148 +type MidiPermissionDescriptor = {|
149 + name: 'midi',
150 + sysex?: boolean,
151 +|};
152 +
153 +type PushPermissionDescriptor = {|
154 + name: 'push',
155 + userVisibleOnly?: boolean,
156 +|};
157 +
158 +type ClipboardPermissionDescriptor = {|
159 + name: 'clipboard-read' | 'clipboard-write',
160 + allowWithoutGesture: boolean,
161 +|};
162 +
163 +type USBPermissionDescriptor = {|
164 + name: 'usb',
165 + filters: Array<USBDeviceFilter>,
166 + exclusionFilters: Array<USBDeviceFilter>,
167 +|};
168 +
169 +type FileSystemHandlePermissionDescriptor = {|
170 + mode: 'read' | 'readwrite',
171 +|};
172 +
173 +declare class PermissionStatus extends EventTarget {
174 + onchange: ?(event: any) => mixed;
175 + +state: PermissionState;
176 +}
177 +
178 +declare class Permissions {
179 + query(
180 + permissionDesc:
181 + | DevicePermissionDescriptor
182 + | MidiPermissionDescriptor
183 + | PushPermissionDescriptor
184 + | ClipboardPermissionDescriptor
185 + | USBPermissionDescriptor
186 + | PermissionDescriptor
187 + ): Promise<PermissionStatus>;
188 +}
189 +
190 +type MIDIPortType = 'input' | 'output';
191 +type MIDIPortDeviceState = 'connected' | 'disconnected';
192 +type MIDIPortConnectionState = 'open' | 'closed' | 'pending';
193 +
194 +type MIDIOptions = {|
195 + sysex: boolean,
196 + software: boolean,
197 +|};
198 +
199 +type MIDIMessageEvent$Init = Event$Init & {
200 + data: Uint8Array,
201 + ...
202 +};
203 +
204 +declare class MIDIMessageEvent extends Event {
205 + constructor(type: string, eventInitDict: MIDIMessageEvent$Init): void;
206 + +data: Uint8Array;
207 +}
208 +
209 +type MIDIConnectionEvent$Init = Event$Init & {
210 + port: MIDIPort,
211 + ...
212 +};
213 +
214 +declare class MIDIConnectionEvent extends Event {
215 + constructor(type: string, eventInitDict: MIDIConnectionEvent$Init): void;
216 + +port: MIDIPort;
217 +}
218 +
219 +declare class MIDIPort extends EventTarget {
220 + +id: string;
221 + +manufacturer?: string;
222 + +name?: string;
223 + +type: MIDIPortType;
224 + +version?: string;
225 + +state: MIDIPortDeviceState;
226 + +connection: MIDIPortConnectionState;
227 + onstatechange: ?(ev: MIDIConnectionEvent) => mixed;
228 + open(): Promise<MIDIPort>;
229 + close(): Promise<MIDIPort>;
230 +}
231 +
232 +declare class MIDIInput extends MIDIPort {
233 + onmidimessage: ?(ev: MIDIMessageEvent) => mixed;
234 +}
235 +
236 +declare class MIDIOutput extends MIDIPort {
237 + send(data: Iterable<number>, timestamp?: number): void;
238 + clear(): void;
239 +}
240 +
241 +declare class MIDIInputMap extends $ReadOnlyMap<string, MIDIInput> {}
242 +
243 +declare class MIDIOutputMap extends $ReadOnlyMap<string, MIDIOutput> {}
244 +
245 +declare class MIDIAccess extends EventTarget {
246 + +inputs: MIDIInputMap;
247 + +outputs: MIDIOutputMap;
248 + +sysexEnabled: boolean;
249 + onstatechange: ?(ev: MIDIConnectionEvent) => mixed;
250 +}
251 +
252 +declare class NavigatorID {
253 + appName: 'Netscape';
254 + appCodeName: 'Mozilla';
255 + product: 'Gecko';
256 + appVersion: string;
257 + platform: string;
258 + userAgent: string;
259 +}
260 +
261 +declare class NavigatorLanguage {
262 + +language: string;
263 + +languages: $ReadOnlyArray<string>;
264 +}
265 +
266 +declare class NavigatorContentUtils {
267 + registerContentHandler(mimeType: string, uri: string, title: string): void;
268 + registerProtocolHandler(protocol: string, uri: string, title: string): void;
269 +}
270 +
271 +declare class NavigatorCookies {
272 + +cookieEnabled: boolean;
273 +}
274 +
275 +declare class NavigatorPlugins {
276 + +plugins: PluginArray;
277 + +mimeTypes: MimeTypeArray;
278 + javaEnabled(): boolean;
279 +}
280 +
281 +declare class NavigatorOnLine {
282 + +onLine: boolean;
283 +}
284 +
285 +declare class NavigatorConcurrentHardware {
286 + +hardwareConcurrency: number;
287 +}
288 +
289 +declare class NavigatorStorage {
290 + storage?: StorageManager;
291 +}
292 +
293 +declare class StorageManager {
294 + persist: () => Promise<boolean>;
295 + persisted: () => Promise<boolean>;
296 + estimate?: () => Promise<StorageEstimate>;
297 + getDirectory: () => Promise<FileSystemDirectoryHandle>;
298 +}
299 +
300 +type StorageManagerRegisteredEndpoint =
301 + | 'caches'
302 + | 'indexedDB'
303 + | 'localStorage'
304 + | 'serviceWorkerRegistrations'
305 + | 'sessionStorage';
306 +
307 +type StorageManagerUsageDetails = {[StorageManagerRegisteredEndpoint]: number};
308 +
309 +declare class StorageEstimate {
310 + constructor(
311 + usage: number,
312 + quota: number,
313 + usageDetails?: StorageManagerUsageDetails
314 + ): void;
315 + +usage: number;
316 + +quota: number;
317 +
318 + // Not a part of the standard
319 + +usageDetails?: StorageManagerUsageDetails;
320 +}
321 +
322 +declare class Navigator
323 + mixins
324 + NavigatorID,
325 + NavigatorLanguage,
326 + NavigatorOnLine,
327 + NavigatorContentUtils,
328 + NavigatorCookies,
329 + NavigatorPlugins,
330 + NavigatorConcurrentHardware,
331 + NavigatorStorage
332 +{
333 + productSub: '20030107' | '20100101';
334 + vendor: '' | 'Google Inc.' | 'Apple Computer, Inc';
335 + vendorSub: '';
336 +
337 + activeVRDisplays?: VRDisplay[];
338 + appCodeName: 'Mozilla';
339 + buildID: string;
340 + doNotTrack: string | null;
341 + geolocation: Geolocation;
342 + mediaDevices?: MediaDevices;
343 + usb?: USB;
344 + maxTouchPoints: number;
345 + permissions: Permissions;
346 + serviceWorker?: ServiceWorkerContainer;
347 + getGamepads?: () => Array<Gamepad | null>;
348 + webkitGetGamepads?: Function;
349 + mozGetGamepads?: Function;
350 + mozGamepads?: any;
351 + gamepads?: any;
352 + webkitGamepads?: any;
353 + getVRDisplays?: () => Promise<VRDisplay[]>;
354 + registerContentHandler(mimeType: string, uri: string, title: string): void;
355 + registerProtocolHandler(protocol: string, uri: string, title: string): void;
356 + requestMIDIAccess?: (options?: MIDIOptions) => Promise<MIDIAccess>;
357 + requestMediaKeySystemAccess?: (
358 + keySystem: string,
359 + supportedConfigurations: any[]
360 + ) => Promise<any>;
361 + sendBeacon?: (url: string, data?: BodyInit) => boolean;
362 + vibrate?: (pattern: number | number[]) => boolean;
363 + mozVibrate?: (pattern: number | number[]) => boolean;
364 + webkitVibrate?: (pattern: number | number[]) => boolean;
365 + canShare?: (shareData?: ShareData) => boolean;
366 + share?: (shareData: ShareData) => Promise<void>;
367 + clipboard: Clipboard;
368 + credentials?: CredMgmtCredentialsContainer;
369 + globalPrivacyControl?: boolean;
370 +
371 + // deprecated
372 + getBattery?: () => Promise<BatteryManager>;
373 + mozGetBattery?: () => Promise<BatteryManager>;
374 +
375 + // deprecated
376 + getUserMedia?: Function;
377 + webkitGetUserMedia?: Function;
378 + mozGetUserMedia?: Function;
379 + msGetUserMedia?: Function;
380 +
381 + // Gecko
382 + taintEnabled?: () => false;
383 + oscpu: string;
384 +}
385 +
386 +declare class Clipboard extends EventTarget {
387 + read(): Promise<DataTransfer>;
388 + readText(): Promise<string>;
389 + write(data: $ReadOnlyArray<ClipboardItem>): Promise<void>;
390 + writeText(data: string): Promise<void>;
391 +}
392 +
393 +declare var navigator: Navigator;
394 +
395 +declare class MimeType {
396 + type: string;
397 + description: string;
398 + suffixes: string;
399 + enabledPlugin: Plugin;
400 +}
401 +
402 +declare class MimeTypeArray {
403 + length: number;
404 + item(index: number): MimeType;
405 + namedItem(name: string): MimeType;
406 + [key: number | string]: MimeType;
407 +}
408 +
409 +declare class Plugin {
410 + description: string;
411 + filename: string;
412 + name: string;
413 + version?: string; // Gecko only
414 + length: number;
415 + item(index: number): MimeType;
416 + namedItem(name: string): MimeType;
417 + [key: number | string]: MimeType;
418 +}
419 +
420 +declare class PluginArray {
421 + length: number;
422 + item(index: number): Plugin;
423 + namedItem(name: string): Plugin;
424 + refresh(): void;
425 + [key: number | string]: Plugin;
426 +}
427 +
428 +// https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp
429 +// https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
430 +declare type DOMHighResTimeStamp = number;
431 +
432 +// https://www.w3.org/TR/navigation-timing-2/
433 +declare class PerformanceTiming {
434 + connectEnd: number;
435 + connectStart: number;
436 + domainLookupEnd: number;
437 + domainLookupStart: number;
438 + domComplete: number;
439 + domContentLoadedEventEnd: number;
440 + domContentLoadedEventStart: number;
441 + domInteractive: number;
442 + domLoading: number;
443 + fetchStart: number;
444 + loadEventEnd: number;
445 + loadEventStart: number;
446 + navigationStart: number;
447 + redirectEnd: number;
448 + redirectStart: number;
449 + requestStart: number;
450 + responseEnd: number;
451 + responseStart: number;
452 + secureConnectionStart: number;
453 + unloadEventEnd: number;
454 + unloadEventStart: number;
455 +}
456 +
457 +declare class PerformanceNavigation {
458 + TYPE_NAVIGATE: 0;
459 + TYPE_RELOAD: 1;
460 + TYPE_BACK_FORWARD: 2;
461 + TYPE_RESERVED: 255;
462 +
463 + type: 0 | 1 | 2 | 255;
464 + redirectCount: number;
465 +}
466 +
467 +type PerformanceEntryFilterOptions = {
468 + name: string,
469 + entryType: string,
470 + initiatorType: string,
471 + ...
472 +};
473 +
474 +// https://www.w3.org/TR/performance-timeline-2/
475 +declare class PerformanceEntry {
476 + name: string;
477 + entryType: string;
478 + startTime: DOMHighResTimeStamp;
479 + duration: DOMHighResTimeStamp;
480 + toJSON(): string;
481 +}
482 +
483 +// https://w3c.github.io/server-timing/#the-performanceservertiming-interface
484 +declare class PerformanceServerTiming {
485 + description: string;
486 + duration: DOMHighResTimeStamp;
487 + name: string;
488 + toJSON(): string;
489 +}
490 +
491 +// https://www.w3.org/TR/resource-timing-2/#sec-performanceresourcetiming
492 +// https://w3c.github.io/server-timing/#extension-to-the-performanceresourcetiming-interface
493 +declare class PerformanceResourceTiming extends PerformanceEntry {
494 + initiatorType: string;
495 + nextHopProtocol: string;
496 + workerStart: number;
497 + redirectStart: number;
498 + redirectEnd: number;
499 + fetchStart: number;
500 + domainLookupStart: number;
501 + domainLookupEnd: number;
502 + connectStart: number;
503 + connectEnd: number;
504 + secureConnectionStart: number;
505 + requestStart: number;
506 + responseStart: number;
507 + responseEnd: number;
508 + transferSize: string;
509 + encodedBodySize: number;
510 + decodedBodySize: number;
511 + serverTiming: Array<PerformanceServerTiming>;
512 +}
513 +
514 +// https://w3c.github.io/event-timing/#sec-performance-event-timing
515 +declare class PerformanceEventTiming extends PerformanceEntry {
516 + processingStart: number;
517 + processingEnd: number;
518 + cancelable: boolean;
519 + target: ?Node;
520 + interactionId: number;
521 +}
522 +
523 +// https://w3c.github.io/longtasks/#taskattributiontiming
524 +declare class TaskAttributionTiming extends PerformanceEntry {
525 + containerType: string;
526 + containerSrc: string;
527 + containerId: string;
528 + containerName: string;
529 +}
530 +
531 +// https://w3c.github.io/longtasks/#sec-PerformanceLongTaskTiming
532 +declare class PerformanceLongTaskTiming extends PerformanceEntry {
533 + attribution: $ReadOnlyArray<TaskAttributionTiming>;
534 +}
535 +
536 +// https://www.w3.org/TR/navigation-timing-2/
537 +declare class PerformanceNavigationTiming extends PerformanceResourceTiming {
538 + unloadEventStart: number;
539 + unloadEventEnd: number;
540 + domInteractive: number;
541 + domContentLoadedEventStart: number;
542 + domContentLoadedEventEnd: number;
543 + domComplete: number;
544 + loadEventStart: number;
545 + loadEventEnd: number;
546 + type: 'navigate' | 'reload' | 'back_forward' | 'prerender';
547 + redirectCount: number;
548 +}
549 +
550 +// https://www.w3.org/TR/user-timing/#extensions-performance-interface
551 +declare type PerformanceMarkOptions = {|
552 + detail?: mixed,
553 + startTime?: number,
554 +|};
555 +
556 +declare type PerformanceMeasureOptions = {|
557 + detail?: mixed,
558 + start?: number | string,
559 + end?: number | string,
560 + duration?: number,
561 +|};
562 +
563 +type EventCountsForEachCallbackType =
564 + | (() => void)
565 + | ((value: number) => void)
566 + | ((value: number, key: string) => void)
567 + | ((value: number, key: string, map: Map<string, number>) => void);
568 +
569 +// https://www.w3.org/TR/event-timing/#eventcounts
570 +declare interface EventCounts {
571 + size: number;
572 +
573 + entries(): Iterator<[string, number]>;
574 + forEach(callback: EventCountsForEachCallbackType): void;
575 + get(key: string): ?number;
576 + has(key: string): boolean;
577 + keys(): Iterator<string>;
578 + values(): Iterator<number>;
579 +}
580 +
581 +declare class Performance {
582 + eventCounts: EventCounts;
583 +
584 + // deprecated
585 + navigation: PerformanceNavigation;
586 + timing: PerformanceTiming;
587 +
588 + onresourcetimingbufferfull: (ev: any) => mixed;
589 + clearMarks(name?: string): void;
590 + clearMeasures(name?: string): void;
591 + clearResourceTimings(): void;
592 + getEntries(options?: PerformanceEntryFilterOptions): Array<PerformanceEntry>;
593 + getEntriesByName(name: string, type?: string): Array<PerformanceEntry>;
594 + getEntriesByType(type: string): Array<PerformanceEntry>;
595 + mark(name: string, options?: PerformanceMarkOptions): void;
596 + measure(
597 + name: string,
598 + startMarkOrOptions?: string | PerformanceMeasureOptions,
599 + endMark?: string
600 + ): void;
601 + now(): DOMHighResTimeStamp;
602 + setResourceTimingBufferSize(maxSize: number): void;
603 + toJSON(): string;
604 +}
605 +
606 +declare var performance: Performance;
607 +
608 +type PerformanceEntryList = PerformanceEntry[];
609 +
610 +declare interface PerformanceObserverEntryList {
611 + getEntries(): PerformanceEntryList;
612 + getEntriesByType(type: string): PerformanceEntryList;
613 + getEntriesByName(name: string, type: ?string): PerformanceEntryList;
614 +}
615 +
616 +type PerformanceObserverInit = {
617 + entryTypes?: string[],
618 + type?: string,
619 + buffered?: boolean,
620 + ...
621 +};
622 +
623 +declare class PerformanceObserver {
624 + constructor(
625 + callback: (
626 + entries: PerformanceObserverEntryList,
627 + observer: PerformanceObserver
628 + ) => mixed
629 + ): void;
630 +
631 + observe(options: ?PerformanceObserverInit): void;
632 + disconnect(): void;
633 + takeRecords(): PerformanceEntryList;
634 +
635 + static supportedEntryTypes: string[];
636 +}
637 +
638 +declare class History {
639 + length: number;
640 + scrollRestoration: 'auto' | 'manual';
641 + state: any;
642 + back(): void;
643 + forward(): void;
644 + go(delta?: number): void;
645 + pushState(statedata: any, title: string, url?: string): void;
646 + replaceState(statedata: any, title: string, url?: string): void;
647 +}
648 +
649 +declare var history: History;
650 +
651 +declare class Location {
652 + ancestorOrigins: string[];
653 + hash: string;
654 + host: string;
655 + hostname: string;
656 + href: string;
657 + origin: string;
658 + pathname: string;
659 + port: string;
660 + protocol: string;
661 + search: string;
662 + assign(url: string): void;
663 + reload(flag?: boolean): void;
664 + replace(url: string): void;
665 + toString(): string;
666 +}
667 +
668 +declare var location: Location;
669 +
670 +///////////////////////////////////////////////////////////////////////////////
671 +
672 +declare class DOMParser {
673 + parseFromString(source: string | TrustedHTML, mimeType: string): Document;
674 +}
675 +
676 +type FormDataEntryValue = string | File;
677 +
678 +declare class FormData {
679 + constructor(form?: HTMLFormElement, submitter?: HTMLElement | null): void;
680 +
681 + has(name: string): boolean;
682 + get(name: string): ?FormDataEntryValue;
683 + getAll(name: string): Array<FormDataEntryValue>;
684 +
685 + set(name: string, value: string): void;
686 + set(name: string, value: Blob, filename?: string): void;
687 + set(name: string, value: File, filename?: string): void;
688 +
689 + append(name: string, value: string): void;
690 + append(name: string, value: Blob, filename?: string): void;
691 + append(name: string, value: File, filename?: string): void;
692 +
693 + delete(name: string): void;
694 +
695 + keys(): Iterator<string>;
696 + values(): Iterator<FormDataEntryValue>;
697 + entries(): Iterator<[string, FormDataEntryValue]>;
698 +}
699 +
700 +declare type IntersectionObserverEntry = {
701 + boundingClientRect: DOMRectReadOnly,
702 + intersectionRatio: number,
703 + intersectionRect: DOMRectReadOnly,
704 + isIntersecting: boolean,
705 + rootBounds: DOMRectReadOnly,
706 + target: Element,
707 + time: DOMHighResTimeStamp,
708 + ...
709 +};
710 +
711 +declare type IntersectionObserverCallback = (
712 + entries: Array<IntersectionObserverEntry>,
713 + observer: IntersectionObserver
714 +) => mixed;
715 +
716 +declare type IntersectionObserverOptions = {
717 + root?: Node | null,
718 + rootMargin?: string,
719 + threshold?: number | Array<number>,
720 + ...
721 +};
722 +
723 +declare class IntersectionObserver {
724 + constructor(
725 + callback: IntersectionObserverCallback,
726 + options?: IntersectionObserverOptions
727 + ): void;
728 + root: Element | null;
729 + rootMargin: string;
730 + scrollMargin: string;
731 + thresholds: number[];
732 + observe(target: Element): void;
733 + unobserve(target: Element): void;
734 + takeRecords(): Array<IntersectionObserverEntry>;
735 + disconnect(): void;
736 +}
737 +
738 +declare interface ResizeObserverSize {
739 + +inlineSize: number;
740 + +blockSize: number;
741 +}
742 +
743 +declare interface ResizeObserverEntry {
744 + /**
745 + * The Element whose size has changed.
746 + */
747 + +target: Element;
748 + /**
749 + * Element's content rect when ResizeObserverCallback is invoked.
750 + *
751 + * Legacy, may be deprecated in the future.
752 + */
753 + +contentRect: DOMRectReadOnly;
754 + /**
755 + * An array containing the Element's border box size when
756 + * ResizeObserverCallback is invoked.
757 + */
758 + +borderBoxSize: $ReadOnlyArray<ResizeObserverSize>;
759 + /**
760 + * An array containing the Element's content rect size when
761 + * ResizeObserverCallback is invoked.
762 + */
763 + +contentBoxSize: $ReadOnlyArray<ResizeObserverSize>;
764 + /**
765 + * An array containing the Element's content rect size in integral device
766 + * pixels when ResizeObserverCallback is invoked.
767 + *
768 + * Not implemented in Firefox or Safari as of July 2021
769 + */
770 + +devicePixelContentBoxSize?: $ReadOnlyArray<ResizeObserverSize> | void;
771 +}
772 +
773 +/**
774 + * ResizeObserver can observe different kinds of CSS sizes:
775 + * - border-box : size of box border area as defined in CSS2.
776 + * - content-box : size of content area as defined in CSS2.
777 + * - device-pixel-content-box : size of content area as defined in CSS2, in device
778 + * pixels, before applying any CSS transforms on the element or its ancestors.
779 + * This size must contain integer values.
780 + */
781 +type ResizeObserverBoxOptions =
782 + | 'border-box'
783 + | 'content-box'
784 + | 'device-pixel-content-box';
785 +
786 +declare type ResizeObserverOptions = {
787 + box?: ResizeObserverBoxOptions,
788 + ...
789 +};
790 +
791 +/**
792 + * The ResizeObserver interface is used to observe changes to Element's size.
793 + */
794 +declare class ResizeObserver {
795 + constructor(
796 + callback: (
797 + entries: ResizeObserverEntry[],
798 + observer: ResizeObserver
799 + ) => mixed
800 + ): void;
801 + /**
802 + * Adds target to the list of observed elements.
803 + */
804 + observe(target: Element, options?: ResizeObserverOptions): void;
805 + /**
806 + * Removes target from the list of observed elements.
807 + */
808 + unobserve(target: Element): void;
809 + disconnect(): void;
810 +}
811 +
812 +declare class CloseEvent extends Event {
813 + code: number;
814 + reason: string;
815 + wasClean: boolean;
816 +}
817 +
818 +declare class WebSocket extends EventTarget {
819 + static CONNECTING: 0;
820 + static OPEN: 1;
821 + static CLOSING: 2;
822 + static CLOSED: 3;
823 + constructor(url: string, protocols?: string | Array<string>): void;
824 + protocol: string;
825 + readyState: number;
826 + bufferedAmount: number;
827 + extensions: string;
828 + onopen: (ev: any) => mixed;
829 + onmessage: (ev: MessageEvent) => mixed;
830 + onclose: (ev: CloseEvent) => mixed;
831 + onerror: (ev: any) => mixed;
832 + binaryType: 'blob' | 'arraybuffer';
833 + url: string;
834 + close(code?: number, reason?: string): void;
835 + send(data: string): void;
836 + send(data: Blob): void;
837 + send(data: ArrayBuffer): void;
838 + send(data: $ArrayBufferView): void;
839 + CONNECTING: 0;
840 + OPEN: 1;
841 + CLOSING: 2;
842 + CLOSED: 3;
843 +}
844 +
845 +type WorkerOptions = {
846 + type?: WorkerType,
847 + credentials?: CredentialsType,
848 + name?: string,
849 + ...
850 +};
851 +
852 +declare class Worker extends EventTarget {
853 + constructor(
854 + stringUrl: string | TrustedScriptURL,
855 + workerOptions?: WorkerOptions
856 + ): void;
857 + onerror: null | ((ev: any) => mixed);
858 + onmessage: null | ((ev: MessageEvent) => mixed);
859 + onmessageerror: null | ((ev: MessageEvent) => mixed);
860 + postMessage(message: any, ports?: any): void;
861 + terminate(): void;
862 +}
863 +
864 +declare class SharedWorker extends EventTarget {
865 + constructor(stringUrl: string | TrustedScriptURL, name?: string): void;
866 + constructor(
867 + stringUrl: string | TrustedScriptURL,
868 + workerOptions?: WorkerOptions
869 + ): void;
870 + port: MessagePort;
871 + onerror: (ev: any) => mixed;
872 +}
873 +
874 +declare function importScripts(...urls: Array<string | TrustedScriptURL>): void;
875 +
876 +declare class WorkerGlobalScope extends EventTarget {
877 + self: this;
878 + location: WorkerLocation;
879 + navigator: WorkerNavigator;
880 + close(): void;
881 + importScripts(...urls: Array<string | TrustedScriptURL>): void;
882 + onerror: (ev: any) => mixed;
883 + onlanguagechange: (ev: any) => mixed;
884 + onoffline: (ev: any) => mixed;
885 + ononline: (ev: any) => mixed;
886 + onrejectionhandled: (ev: PromiseRejectionEvent) => mixed;
887 + onunhandledrejection: (ev: PromiseRejectionEvent) => mixed;
888 +}
889 +
890 +declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {
891 + onmessage: (ev: MessageEvent) => mixed;
892 + onmessageerror: (ev: MessageEvent) => mixed;
893 + postMessage(message: any, transfer?: Iterable<any>): void;
894 +}
895 +
896 +declare class SharedWorkerGlobalScope extends WorkerGlobalScope {
897 + name: string;
898 + onconnect: (ev: MessageEvent) => mixed;
899 +}
900 +
901 +declare class WorkerLocation {
902 + origin: string;
903 + protocol: string;
904 + host: string;
905 + hostname: string;
906 + port: string;
907 + pathname: string;
908 + search: string;
909 + hash: string;
910 +}
911 +
912 +declare class WorkerNavigator
913 + mixins
914 + NavigatorID,
915 + NavigatorLanguage,
916 + NavigatorOnLine,
917 + NavigatorConcurrentHardware,
918 + NavigatorStorage
919 +{
920 + permissions: Permissions;
921 +}
922 +
923 +// deprecated
924 +declare class XDomainRequest {
925 + timeout: number;
926 + onerror: () => mixed;
927 + onload: () => mixed;
928 + onprogress: () => mixed;
929 + ontimeout: () => mixed;
930 + +responseText: string;
931 + +contentType: string;
932 + open(method: 'GET' | 'POST', url: string): void;
933 + abort(): void;
934 + send(data?: string): void;
935 +
936 + statics: {create(): XDomainRequest, ...};
937 +}
938 +
939 +declare class XMLHttpRequest extends EventTarget {
940 + static LOADING: number;
941 + static DONE: number;
942 + static UNSENT: number;
943 + static OPENED: number;
944 + static HEADERS_RECEIVED: number;
945 + responseBody: any;
946 + status: number;
947 + readyState: number;
948 + responseText: string;
949 + responseXML: any;
950 + responseURL: string;
951 + ontimeout: ProgressEventHandler;
952 + statusText: string;
953 + onreadystatechange: (ev: any) => mixed;
954 + timeout: number;
955 + onload: ProgressEventHandler;
956 + response: any;
957 + withCredentials: boolean;
958 + onprogress: ProgressEventHandler;
959 + onabort: ProgressEventHandler;
960 + responseType: string;
961 + onloadend: ProgressEventHandler;
962 + upload: XMLHttpRequestEventTarget;
963 + onerror: ProgressEventHandler;
964 + onloadstart: ProgressEventHandler;
965 + msCaching: string;
966 + open(
967 + method: string,
968 + url: string,
969 + async?: boolean,
970 + user?: string,
971 + password?: string
972 + ): void;
973 + send(data?: any): void;
974 + abort(): void;
975 + getAllResponseHeaders(): string;
976 + setRequestHeader(header: string, value: string): void;
977 + getResponseHeader(header: string): string;
978 + msCachingEnabled(): boolean;
979 + overrideMimeType(mime: string): void;
980 + LOADING: number;
981 + DONE: number;
982 + UNSENT: number;
983 + OPENED: number;
984 + HEADERS_RECEIVED: number;
985 +
986 + statics: {create(): XMLHttpRequest, ...};
987 +}
988 +
989 +declare class XMLHttpRequestEventTarget extends EventTarget {
990 + onprogress: ProgressEventHandler;
991 + onerror: ProgressEventHandler;
992 + onload: ProgressEventHandler;
993 + ontimeout: ProgressEventHandler;
994 + onabort: ProgressEventHandler;
995 + onloadstart: ProgressEventHandler;
996 + onloadend: ProgressEventHandler;
997 +}
998 +
999 +declare class XMLSerializer {
1000 + serializeToString(target: Node): string;
1001 +}
1002 +
1003 +declare class Geolocation {
1004 + getCurrentPosition(
1005 + success: (position: Position) => mixed,
1006 + error?: (error: PositionError) => mixed,
1007 + options?: PositionOptions
1008 + ): void;
1009 + watchPosition(
1010 + success: (position: Position) => mixed,
1011 + error?: (error: PositionError) => mixed,
1012 + options?: PositionOptions
1013 + ): number;
1014 + clearWatch(id: number): void;
1015 +}
1016 +
1017 +declare class Position {
1018 + coords: Coordinates;
1019 + timestamp: number;
1020 +}
1021 +
1022 +declare class Coordinates {
1023 + latitude: number;
1024 + longitude: number;
1025 + altitude?: number;
1026 + accuracy: number;
1027 + altitudeAccuracy?: number;
1028 + heading?: number;
1029 + speed?: number;
1030 +}
1031 +
1032 +declare class PositionError {
1033 + code: number;
1034 + message: string;
1035 + PERMISSION_DENIED: 1;
1036 + POSITION_UNAVAILABLE: 2;
1037 + TIMEOUT: 3;
1038 +}
1039 +
1040 +type PositionOptions = {
1041 + enableHighAccuracy?: boolean,
1042 + timeout?: number,
1043 + maximumAge?: number,
1044 + ...
1045 +};
1046 +
1047 +type AudioContextState = 'suspended' | 'running' | 'closed';
1048 +
1049 +// deprecated
1050 +type AudioProcessingEvent$Init = Event$Init & {
1051 + playbackTime: number,
1052 + inputBuffer: AudioBuffer,
1053 + outputBuffer: AudioBuffer,
1054 + ...
1055 +};
1056 +
1057 +// deprecated
1058 +declare class AudioProcessingEvent extends Event {
1059 + constructor(type: string, eventInitDict: AudioProcessingEvent$Init): void;
1060 +
1061 + +playbackTime: number;
1062 + +inputBuffer: AudioBuffer;
1063 + +outputBuffer: AudioBuffer;
1064 +}
1065 +
1066 +type OfflineAudioCompletionEvent$Init = Event$Init & {
1067 + renderedBuffer: AudioBuffer,
1068 + ...
1069 +};
1070 +
1071 +declare class OfflineAudioCompletionEvent extends Event {
1072 + constructor(
1073 + type: string,
1074 + eventInitDict: OfflineAudioCompletionEvent$Init
1075 + ): void;
1076 +
1077 + +renderedBuffer: AudioBuffer;
1078 +}
1079 +
1080 +declare class BaseAudioContext extends EventTarget {
1081 + currentTime: number;
1082 + destination: AudioDestinationNode;
1083 + listener: AudioListener;
1084 + sampleRate: number;
1085 + state: AudioContextState;
1086 + onstatechange: (ev: any) => mixed;
1087 + createBuffer(
1088 + numOfChannels: number,
1089 + length: number,
1090 + sampleRate: number
1091 + ): AudioBuffer;
1092 + createBufferSource(myMediaElement?: HTMLMediaElement): AudioBufferSourceNode;
1093 + createMediaElementSource(
1094 + myMediaElement: HTMLMediaElement
1095 + ): MediaElementAudioSourceNode;
1096 + createMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode;
1097 + createMediaStreamDestination(): MediaStreamAudioDestinationNode;
1098 +
1099 + // deprecated
1100 + createScriptProcessor(
1101 + bufferSize: number,
1102 + numberOfInputChannels: number,
1103 + numberOfOutputChannels: number
1104 + ): ScriptProcessorNode;
1105 +
1106 + createAnalyser(): AnalyserNode;
1107 + createBiquadFilter(): BiquadFilterNode;
1108 + createChannelMerger(numberOfInputs?: number): ChannelMergerNode;
1109 + createChannelSplitter(numberOfInputs?: number): ChannelSplitterNode;
1110 + createConstantSource(): ConstantSourceNode;
1111 + createConvolver(): ConvolverNode;
1112 + createDelay(maxDelayTime?: number): DelayNode;
1113 + createDynamicsCompressor(): DynamicsCompressorNode;
1114 + createGain(): GainNode;
1115 + createIIRFilter(
1116 + feedforward: Float32Array,
1117 + feedback: Float32Array
1118 + ): IIRFilterNode;
1119 + createOscillator(): OscillatorNode;
1120 + createPanner(): PannerNode;
1121 + createStereoPanner(): StereoPannerNode;
1122 + createPeriodicWave(
1123 + real: Float32Array,
1124 + img: Float32Array,
1125 + options?: {disableNormalization: boolean, ...}
1126 + ): PeriodicWave;
1127 + createStereoPanner(): StereoPannerNode;
1128 + createWaveShaper(): WaveShaperNode;
1129 + decodeAudioData(
1130 + arrayBuffer: ArrayBuffer,
1131 + decodeSuccessCallback: (decodedData: AudioBuffer) => mixed,
1132 + decodeErrorCallback: (err: DOMError) => mixed
1133 + ): void;
1134 + decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
1135 +}
1136 +
1137 +declare class AudioTimestamp {
1138 + contextTime: number;
1139 + performanceTime: number;
1140 +}
1141 +
1142 +declare class AudioContext extends BaseAudioContext {
1143 + constructor(options?: {|
1144 + latencyHint?: 'balanced' | 'interactive' | 'playback' | number,
1145 + sampleRate?: number,
1146 + |}): AudioContext;
1147 + baseLatency: number;
1148 + outputLatency: number;
1149 + getOutputTimestamp(): AudioTimestamp;
1150 + resume(): Promise<void>;
1151 + suspend(): Promise<void>;
1152 + close(): Promise<void>;
1153 + createMediaElementSource(
1154 + myMediaElement: HTMLMediaElement
1155 + ): MediaElementAudioSourceNode;
1156 + createMediaStreamSource(
1157 + myMediaStream: MediaStream
1158 + ): MediaStreamAudioSourceNode;
1159 + createMediaStreamTrackSource(
1160 + myMediaStreamTrack: MediaStreamTrack
1161 + ): MediaStreamTrackAudioSourceNode;
1162 + createMediaStreamDestination(): MediaStreamAudioDestinationNode;
1163 +}
1164 +
1165 +declare class OfflineAudioContext extends BaseAudioContext {
1166 + startRendering(): Promise<AudioBuffer>;
1167 + suspend(suspendTime: number): Promise<void>;
1168 + length: number;
1169 + oncomplete: (ev: OfflineAudioCompletionEvent) => mixed;
1170 +}
1171 +
1172 +declare class AudioNode extends EventTarget {
1173 + context: AudioContext;
1174 + numberOfInputs: number;
1175 + numberOfOutputs: number;
1176 + channelCount: number;
1177 + channelCountMode: 'max' | 'clamped-max' | 'explicit';
1178 + channelInterpretation: 'speakers' | 'discrete';
1179 + connect(audioNode: AudioNode, output?: number, input?: number): AudioNode;
1180 + connect(destination: AudioParam, output?: number): void;
1181 + disconnect(destination?: AudioNode, output?: number, input?: number): void;
1182 +}
1183 +
1184 +declare class AudioParam extends AudioNode {
1185 + value: number;
1186 + defaultValue: number;
1187 + setValueAtTime(value: number, startTime: number): this;
1188 + linearRampToValueAtTime(value: number, endTime: number): this;
1189 + exponentialRampToValueAtTime(value: number, endTime: number): this;
1190 + setTargetAtTime(
1191 + target: number,
1192 + startTime: number,
1193 + timeConstant: number
1194 + ): this;
1195 + setValueCurveAtTime(
1196 + values: Float32Array,
1197 + startTime: number,
1198 + duration: number
1199 + ): this;
1200 + cancelScheduledValues(startTime: number): this;
1201 +}
1202 +
1203 +declare class AudioDestinationNode extends AudioNode {
1204 + maxChannelCount: number;
1205 +}
1206 +
1207 +declare class AudioListener extends AudioNode {
1208 + positionX: AudioParam;
1209 + positionY: AudioParam;
1210 + positionZ: AudioParam;
1211 + forwardX: AudioParam;
1212 + forwardY: AudioParam;
1213 + forwardZ: AudioParam;
1214 + upX: AudioParam;
1215 + upY: AudioParam;
1216 + upZ: AudioParam;
1217 + setPosition(x: number, y: number, c: number): void;
1218 + setOrientation(
1219 + x: number,
1220 + y: number,
1221 + z: number,
1222 + xUp: number,
1223 + yUp: number,
1224 + zUp: number
1225 + ): void;
1226 +}
1227 +
1228 +declare class AudioBuffer {
1229 + sampleRate: number;
1230 + length: number;
1231 + duration: number;
1232 + numberOfChannels: number;
1233 + getChannelData(channel: number): Float32Array;
1234 + copyFromChannel(
1235 + destination: Float32Array,
1236 + channelNumber: number,
1237 + startInChannel?: number
1238 + ): void;
1239 + copyToChannel(
1240 + source: Float32Array,
1241 + channelNumber: number,
1242 + startInChannel?: number
1243 + ): void;
1244 +}
1245 +
1246 +declare class AudioBufferSourceNode extends AudioNode {
1247 + buffer: AudioBuffer;
1248 + detune: AudioParam;
1249 + loop: boolean;
1250 + loopStart: number;
1251 + loopEnd: number;
1252 + playbackRate: AudioParam;
1253 + onended: (ev: any) => mixed;
1254 + start(when?: number, offset?: number, duration?: number): void;
1255 + stop(when?: number): void;
1256 +}
1257 +
1258 +declare class CanvasCaptureMediaStream extends MediaStream {
1259 + canvas: HTMLCanvasElement;
1260 + requestFrame(): void;
1261 +}
1262 +
1263 +type DoubleRange = {
1264 + max?: number,
1265 + min?: number,
1266 + ...
1267 +};
1268 +
1269 +type LongRange = {
1270 + max?: number,
1271 + min?: number,
1272 + ...
1273 +};
1274 +
1275 +type ConstrainBooleanParameters = {
1276 + exact?: boolean,
1277 + ideal?: boolean,
1278 + ...
1279 +};
1280 +
1281 +type ConstrainDOMStringParameters = {
1282 + exact?: string | string[],
1283 + ideal?: string | string[],
1284 + ...
1285 +};
1286 +
1287 +type ConstrainDoubleRange = {
1288 + ...DoubleRange,
1289 + exact?: number,
1290 + ideal?: number,
1291 + ...
1292 +};
1293 +
1294 +type ConstrainLongRange = {
1295 + ...LongRange,
1296 + exact?: number,
1297 + ideal?: number,
1298 + ...
1299 +};
1300 +
1301 +type MediaTrackSupportedConstraints = {|
1302 + width: boolean,
1303 + height: boolean,
1304 + aspectRatio: boolean,
1305 + frameRate: boolean,
1306 + facingMode: boolean,
1307 + resizeMode: boolean,
1308 + volume: boolean,
1309 + sampleRate: boolean,
1310 + sampleSize: boolean,
1311 + echoCancellation: boolean,
1312 + autoGainControl: boolean,
1313 + noiseSuppression: boolean,
1314 + latency: boolean,
1315 + channelCount: boolean,
1316 + deviceId: boolean,
1317 + groupId: boolean,
1318 +|};
1319 +
1320 +type MediaTrackConstraintSet = {
1321 + width?: number | ConstrainLongRange,
1322 + height?: number | ConstrainLongRange,
1323 + aspectRatio?: number | ConstrainDoubleRange,
1324 + frameRate?: number | ConstrainDoubleRange,
1325 + facingMode?: string | string[] | ConstrainDOMStringParameters,
1326 + resizeMode?: string | string[] | ConstrainDOMStringParameters,
1327 + volume?: number | ConstrainDoubleRange,
1328 + sampleRate?: number | ConstrainLongRange,
1329 + sampleSize?: number | ConstrainLongRange,
1330 + echoCancellation?: boolean | ConstrainBooleanParameters,
1331 + autoGainControl?: boolean | ConstrainBooleanParameters,
1332 + noiseSuppression?: boolean | ConstrainBooleanParameters,
1333 + latency?: number | ConstrainDoubleRange,
1334 + channelCount?: number | ConstrainLongRange,
1335 + deviceId?: string | string[] | ConstrainDOMStringParameters,
1336 + groupId?: string | string[] | ConstrainDOMStringParameters,
1337 + ...
1338 +};
1339 +
1340 +type MediaTrackConstraints = {
1341 + ...MediaTrackConstraintSet,
1342 + advanced?: Array<MediaTrackConstraintSet>,
1343 + ...
1344 +};
1345 +
1346 +type DisplayMediaStreamConstraints = {
1347 + video?: boolean | MediaTrackConstraints,
1348 + audio?: boolean | MediaTrackConstraints,
1349 + ...
1350 +};
1351 +
1352 +type MediaStreamConstraints = {
1353 + audio?: boolean | MediaTrackConstraints,
1354 + video?: boolean | MediaTrackConstraints,
1355 + peerIdentity?: string,
1356 + ...
1357 +};
1358 +
1359 +type MediaTrackSettings = {
1360 + aspectRatio?: number,
1361 + deviceId?: string,
1362 + displaySurface?: 'application' | 'browser' | 'monitor' | 'window',
1363 + echoCancellation?: boolean,
1364 + facingMode?: string,
1365 + frameRate?: number,
1366 + groupId?: string,
1367 + height?: number,
1368 + logicalSurface?: boolean,
1369 + sampleRate?: number,
1370 + sampleSize?: number,
1371 + volume?: number,
1372 + width?: number,
1373 + ...
1374 +};
1375 +
1376 +type MediaTrackCapabilities = {
1377 + aspectRatio?: number | DoubleRange,
1378 + deviceId?: string,
1379 + echoCancellation?: boolean[],
1380 + facingMode?: string,
1381 + frameRate?: number | DoubleRange,
1382 + groupId?: string,
1383 + height?: number | LongRange,
1384 + sampleRate?: number | LongRange,
1385 + sampleSize?: number | LongRange,
1386 + volume?: number | DoubleRange,
1387 + width?: number | LongRange,
1388 + ...
1389 +};
1390 +
1391 +declare class MediaDevices extends EventTarget {
1392 + ondevicechange: (ev: any) => mixed;
1393 + enumerateDevices: () => Promise<Array<MediaDeviceInfo>>;
1394 + getSupportedConstraints: () => MediaTrackSupportedConstraints;
1395 + getDisplayMedia: (
1396 + constraints?: DisplayMediaStreamConstraints
1397 + ) => Promise<MediaStream>;
1398 + getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
1399 +}
1400 +
1401 +declare class MediaDeviceInfo {
1402 + +deviceId: string;
1403 + +groupId: string;
1404 + +kind: 'videoinput' | 'audioinput' | 'audiooutput';
1405 + +label: string;
1406 +}
1407 +
1408 +type MediaRecorderOptions = {
1409 + mimeType?: string,
1410 + audioBitsPerSecond?: number,
1411 + videoBitsPerSecond?: number,
1412 + bitsPerSecond?: number,
1413 + audioBitrateMode?: 'cbr' | 'vbr',
1414 + ...
1415 +};
1416 +
1417 +declare class MediaRecorder extends EventTarget {
1418 + constructor(stream: MediaStream, options?: MediaRecorderOptions): void;
1419 + +stream: MediaStream;
1420 + +mimeType: string;
1421 + +state: 'inactive' | 'recording' | 'paused';
1422 +
1423 + onstart: (ev: any) => mixed;
1424 + onstop: (ev: any) => mixed;
1425 + ondataavailable: (ev: any) => mixed;
1426 + onpause: (ev: any) => mixed;
1427 + onresume: (ev: any) => mixed;
1428 + onerror: (ev: any) => mixed;
1429 +
1430 + +videoBitsPerSecond: number;
1431 + +audioBitsPerSecond: number;
1432 + +audioBitrateMode: 'cbr' | 'vbr';
1433 +
1434 + start(timeslice?: number): void;
1435 + stop(): void;
1436 + pause(): void;
1437 + resume(): void;
1438 + requestData(): void;
1439 +
1440 + static isTypeSupported(type: string): boolean;
1441 +}
1442 +
1443 +declare class MediaStream extends EventTarget {
1444 + active: boolean;
1445 + ended: boolean;
1446 + id: string;
1447 + onactive: (ev: any) => mixed;
1448 + oninactive: (ev: any) => mixed;
1449 + onended: (ev: any) => mixed;
1450 + onaddtrack: (ev: MediaStreamTrackEvent) => mixed;
1451 + onremovetrack: (ev: MediaStreamTrackEvent) => mixed;
1452 + addTrack(track: MediaStreamTrack): void;
1453 + clone(): MediaStream;
1454 + getAudioTracks(): MediaStreamTrack[];
1455 + getTrackById(trackid?: string): ?MediaStreamTrack;
1456 + getTracks(): MediaStreamTrack[];
1457 + getVideoTracks(): MediaStreamTrack[];
1458 + removeTrack(track: MediaStreamTrack): void;
1459 +}
1460 +
1461 +declare class MediaStreamTrack extends EventTarget {
1462 + enabled: boolean;
1463 + id: string;
1464 + kind: string;
1465 + label: string;
1466 + muted: boolean;
1467 + readonly: boolean;
1468 + readyState: 'live' | 'ended';
1469 + remote: boolean;
1470 + contentHint?: string;
1471 + onstarted: (ev: any) => mixed;
1472 + onmute: (ev: any) => mixed;
1473 + onunmute: (ev: any) => mixed;
1474 + onoverconstrained: (ev: any) => mixed;
1475 + onended: (ev: any) => mixed;
1476 + getConstraints(): MediaTrackConstraints;
1477 + applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;
1478 + getSettings(): MediaTrackSettings;
1479 + getCapabilities(): MediaTrackCapabilities;
1480 + clone(): MediaStreamTrack;
1481 + stop(): void;
1482 +}
1483 +
1484 +declare class MediaStreamTrackEvent extends Event {
1485 + track: MediaStreamTrack;
1486 +}
1487 +
1488 +declare class MediaElementAudioSourceNode extends AudioNode {}
1489 +declare class MediaStreamAudioSourceNode extends AudioNode {}
1490 +declare class MediaStreamTrackAudioSourceNode extends AudioNode {}
1491 +
1492 +declare class MediaStreamAudioDestinationNode extends AudioNode {
1493 + stream: MediaStream;
1494 +}
1495 +
1496 +// deprecated
1497 +declare class ScriptProcessorNode extends AudioNode {
1498 + bufferSize: number;
1499 + onaudioprocess: (ev: AudioProcessingEvent) => mixed;
1500 +}
1501 +
1502 +declare class AnalyserNode extends AudioNode {
1503 + fftSize: number;
1504 + frequencyBinCount: number;
1505 + minDecibels: number;
1506 + maxDecibels: number;
1507 + smoothingTimeConstant: number;
1508 + getFloatFrequencyData(array: Float32Array): Float32Array;
1509 + getByteFrequencyData(array: Uint8Array): Uint8Array;
1510 + getFloatTimeDomainData(array: Float32Array): Float32Array;
1511 + getByteTimeDomainData(array: Uint8Array): Uint8Array;
1512 +}
1513 +
1514 +declare class BiquadFilterNode extends AudioNode {
1515 + frequency: AudioParam;
1516 + detune: AudioParam;
1517 + Q: AudioParam;
1518 + gain: AudioParam;
1519 + type:
1520 + | 'lowpass'
1521 + | 'highpass'
1522 + | 'bandpass'
1523 + | 'lowshelf'
1524 + | 'highshelf'
1525 + | 'peaking'
1526 + | 'notch'
1527 + | 'allpass';
1528 + getFrequencyResponse(
1529 + frequencyHz: Float32Array,
1530 + magResponse: Float32Array,
1531 + phaseResponse: Float32Array
1532 + ): void;
1533 +}
1534 +
1535 +declare class ChannelMergerNode extends AudioNode {}
1536 +declare class ChannelSplitterNode extends AudioNode {}
1537 +
1538 +type ConstantSourceOptions = {offset?: number, ...};
1539 +declare class ConstantSourceNode extends AudioNode {
1540 + constructor(context: BaseAudioContext, options?: ConstantSourceOptions): void;
1541 + offset: AudioParam;
1542 + onended: (ev: any) => mixed;
1543 + start(when?: number): void;
1544 + stop(when?: number): void;
1545 +}
1546 +
1547 +declare class ConvolverNode extends AudioNode {
1548 + buffer: AudioBuffer;
1549 + normalize: boolean;
1550 +}
1551 +
1552 +declare class DelayNode extends AudioNode {
1553 + delayTime: number;
1554 +}
1555 +
1556 +declare class DynamicsCompressorNode extends AudioNode {
1557 + threshold: AudioParam;
1558 + knee: AudioParam;
1559 + ratio: AudioParam;
1560 + reduction: AudioParam;
1561 + attack: AudioParam;
1562 + release: AudioParam;
1563 +}
1564 +
1565 +declare class GainNode extends AudioNode {
1566 + gain: AudioParam;
1567 +}
1568 +
1569 +declare class IIRFilterNode extends AudioNode {
1570 + getFrequencyResponse(
1571 + frequencyHz: Float32Array,
1572 + magResponse: Float32Array,
1573 + phaseResponse: Float32Array
1574 + ): void;
1575 +}
1576 +
1577 +declare class OscillatorNode extends AudioNode {
1578 + frequency: AudioParam;
1579 + detune: AudioParam;
1580 + type: 'sine' | 'square' | 'sawtooth' | 'triangle' | 'custom';
1581 + start(when?: number): void;
1582 + stop(when?: number): void;
1583 + setPeriodicWave(periodicWave: PeriodicWave): void;
1584 + onended: (ev: any) => mixed;
1585 +}
1586 +
1587 +declare class StereoPannerNode extends AudioNode {
1588 + pan: AudioParam;
1589 +}
1590 +
1591 +declare class PannerNode extends AudioNode {
1592 + panningModel: 'equalpower' | 'HRTF';
1593 + distanceModel: 'linear' | 'inverse' | 'exponential';
1594 + refDistance: number;
1595 + maxDistance: number;
1596 + rolloffFactor: number;
1597 + coneInnerAngle: number;
1598 + coneOuterAngle: number;
1599 + coneOuterGain: number;
1600 + setPosition(x: number, y: number, z: number): void;
1601 + setOrientation(x: number, y: number, z: number): void;
1602 +}
1603 +
1604 +declare class PeriodicWave extends AudioNode {}
1605 +declare class WaveShaperNode extends AudioNode {
1606 + curve: Float32Array;
1607 + oversample: 'none' | '2x' | '4x';
1608 +}
1609 +
1610 +// this part of spec is not finished yet, apparently
1611 +// https://stackoverflow.com/questions/35296664/can-fetch-get-object-as-headers
1612 +type HeadersInit =
1613 + | Headers
1614 + | Array<[string, string]>
1615 + | {[key: string]: string, ...};
1616 +
1617 +// TODO Heades and URLSearchParams are almost the same thing.
1618 +// Could it somehow be abstracted away?
1619 +declare class Headers {
1620 + @@iterator(): Iterator<[string, string]>;
1621 + constructor(init?: HeadersInit): void;
1622 + append(name: string, value: string): void;
1623 + delete(name: string): void;
1624 + entries(): Iterator<[string, string]>;
1625 + forEach<This>(
1626 + callback: (
1627 + this: This,
1628 + value: string,
1629 + name: string,
1630 + headers: Headers
1631 + ) => mixed,
1632 + thisArg: This
1633 + ): void;
1634 + get(name: string): null | string;
1635 + has(name: string): boolean;
1636 + keys(): Iterator<string>;
1637 + set(name: string, value: string): void;
1638 + values(): Iterator<string>;
1639 +}
1640 +
1641 +declare class URLSearchParams {
1642 + @@iterator(): Iterator<[string, string]>;
1643 +
1644 + size: number;
1645 +
1646 + constructor(
1647 + init?:
1648 + | string
1649 + | URLSearchParams
1650 + | Array<[string, string]>
1651 + | {[string]: string, ...}
1652 + ): void;
1653 + append(name: string, value: string): void;
1654 + delete(name: string, value?: string): void;
1655 + entries(): Iterator<[string, string]>;
1656 + forEach<This>(
1657 + callback: (
1658 + this: This,
1659 + value: string,
1660 + name: string,
1661 + params: URLSearchParams
1662 + ) => mixed,
1663 + thisArg: This
1664 + ): void;
1665 + get(name: string): null | string;
1666 + getAll(name: string): Array<string>;
1667 + has(name: string, value?: string): boolean;
1668 + keys(): Iterator<string>;
1669 + set(name: string, value: string): void;
1670 + sort(): void;
1671 + values(): Iterator<string>;
1672 + toString(): string;
1673 +}
1674 +
1675 +type CacheType =
1676 + | 'default'
1677 + | 'no-store'
1678 + | 'reload'
1679 + | 'no-cache'
1680 + | 'force-cache'
1681 + | 'only-if-cached';
1682 +type CredentialsType = 'omit' | 'same-origin' | 'include';
1683 +type ModeType = 'cors' | 'no-cors' | 'same-origin' | 'navigate';
1684 +type RedirectType = 'follow' | 'error' | 'manual';
1685 +type ReferrerPolicyType =
1686 + | ''
1687 + | 'no-referrer'
1688 + | 'no-referrer-when-downgrade'
1689 + | 'same-origin'
1690 + | 'origin'
1691 + | 'strict-origin'
1692 + | 'origin-when-cross-origin'
1693 + | 'strict-origin-when-cross-origin'
1694 + | 'unsafe-url';
1695 +
1696 +type ResponseType =
1697 + | 'basic'
1698 + | 'cors'
1699 + | 'default'
1700 + | 'error'
1701 + | 'opaque'
1702 + | 'opaqueredirect';
1703 +
1704 +type BodyInit =
1705 + | string
1706 + | URLSearchParams
1707 + | FormData
1708 + | Blob
1709 + | ArrayBuffer
1710 + | $ArrayBufferView
1711 + | ReadableStream;
1712 +
1713 +type RequestInfo = Request | URL | string;
1714 +
1715 +type RequestOptions = {
1716 + body?: ?BodyInit,
1717 + cache?: CacheType,
1718 + credentials?: CredentialsType,
1719 + headers?: HeadersInit,
1720 + integrity?: string,
1721 + keepalive?: boolean,
1722 + method?: string,
1723 + mode?: ModeType,
1724 + redirect?: RedirectType,
1725 + referrer?: string,
1726 + referrerPolicy?: ReferrerPolicyType,
1727 + signal?: ?AbortSignal,
1728 + window?: any,
1729 + ...
1730 +};
1731 +
1732 +type ResponseOptions = {
1733 + status?: number,
1734 + statusText?: string,
1735 + headers?: HeadersInit,
1736 + ...
1737 +};
1738 +
1739 +declare class Response {
1740 + constructor(input?: ?BodyInit, init?: ResponseOptions): void;
1741 + clone(): Response;
1742 + static error(): Response;
1743 + static redirect(url: string, status?: number): Response;
1744 +
1745 + redirected: boolean;
1746 + type: ResponseType;
1747 + url: string;
1748 + ok: boolean;
1749 + status: number;
1750 + statusText: string;
1751 + headers: Headers;
1752 + trailer: Promise<Headers>;
1753 +
1754 + // Body methods and attributes
1755 + bodyUsed: boolean;
1756 + body: ?ReadableStream;
1757 +
1758 + arrayBuffer(): Promise<ArrayBuffer>;
1759 + blob(): Promise<Blob>;
1760 + formData(): Promise<FormData>;
1761 + json(): Promise<any>;
1762 + text(): Promise<string>;
1763 +}
1764 +
1765 +declare class Request {
1766 + constructor(input: RequestInfo, init?: RequestOptions): void;
1767 + clone(): Request;
1768 +
1769 + url: string;
1770 +
1771 + cache: CacheType;
1772 + credentials: CredentialsType;
1773 + headers: Headers;
1774 + integrity: string;
1775 + method: string;
1776 + mode: ModeType;
1777 + redirect: RedirectType;
1778 + referrer: string;
1779 + referrerPolicy: ReferrerPolicyType;
1780 + +signal: AbortSignal;
1781 +
1782 + // Body methods and attributes
1783 + bodyUsed: boolean;
1784 +
1785 + arrayBuffer(): Promise<ArrayBuffer>;
1786 + blob(): Promise<Blob>;
1787 + formData(): Promise<FormData>;
1788 + json(): Promise<any>;
1789 + text(): Promise<string>;
1790 +}
1791 +
1792 +declare function fetch(
1793 + input: RequestInfo,
1794 + init?: RequestOptions
1795 +): Promise<Response>;
1796 +
1797 +type TextEncoder$availableEncodings =
1798 + | 'utf-8'
1799 + | 'utf8'
1800 + | 'unicode-1-1-utf-8'
1801 + | 'utf-16be'
1802 + | 'utf-16'
1803 + | 'utf-16le';
1804 +
1805 +declare class TextEncoder {
1806 + constructor(encoding?: TextEncoder$availableEncodings): void;
1807 + encode(buffer: string, options?: {stream: boolean, ...}): Uint8Array;
1808 + encoding: TextEncoder$availableEncodings;
1809 +}
1810 +
1811 +type TextDecoder$availableEncodings =
1812 + | '866'
1813 + | 'ansi_x3.4-1968'
1814 + | 'arabic'
1815 + | 'ascii'
1816 + | 'asmo-708'
1817 + | 'big5-hkscs'
1818 + | 'big5'
1819 + | 'chinese'
1820 + | 'cn-big5'
1821 + | 'cp1250'
1822 + | 'cp1251'
1823 + | 'cp1252'
1824 + | 'cp1253'
1825 + | 'cp1254'
1826 + | 'cp1255'
1827 + | 'cp1256'
1828 + | 'cp1257'
1829 + | 'cp1258'
1830 + | 'cp819'
1831 + | 'cp866'
1832 + | 'csbig5'
1833 + | 'cseuckr'
1834 + | 'cseucpkdfmtjapanese'
1835 + | 'csgb2312'
1836 + | 'csibm866'
1837 + | 'csiso2022jp'
1838 + | 'csiso2022kr'
1839 + | 'csiso58gb231280'
1840 + | 'csiso88596e'
1841 + | 'csiso88596i'
1842 + | 'csiso88598e'
1843 + | 'csiso88598i'
1844 + | 'csisolatin1'
1845 + | 'csisolatin2'
1846 + | 'csisolatin3'
1847 + | 'csisolatin4'
1848 + | 'csisolatin5'
1849 + | 'csisolatin6'
1850 + | 'csisolatin9'
1851 + | 'csisolatinarabic'
1852 + | 'csisolatincyrillic'
1853 + | 'csisolatingreek'
1854 + | 'csisolatinhebrew'
1855 + | 'cskoi8r'
1856 + | 'csksc56011987'
1857 + | 'csmacintosh'
1858 + | 'csshiftjis'
1859 + | 'cyrillic'
1860 + | 'dos-874'
1861 + | 'ecma-114'
1862 + | 'ecma-118'
1863 + | 'elot_928'
1864 + | 'euc-jp'
1865 + | 'euc-kr'
1866 + | 'gb_2312-80'
1867 + | 'gb_2312'
1868 + | 'gb18030'
1869 + | 'gb2312'
1870 + | 'gbk'
1871 + | 'greek'
1872 + | 'greek8'
1873 + | 'hebrew'
1874 + | 'hz-gb-2312'
1875 + | 'ibm819'
1876 + | 'ibm866'
1877 + | 'iso_8859-1:1987'
1878 + | 'iso_8859-1'
1879 + | 'iso_8859-2:1987'
1880 + | 'iso_8859-2'
1881 + | 'iso_8859-3:1988'
1882 + | 'iso_8859-3'
1883 + | 'iso_8859-4:1988'
1884 + | 'iso_8859-4'
1885 + | 'iso_8859-5:1988'
1886 + | 'iso_8859-5'
1887 + | 'iso_8859-6:1987'
1888 + | 'iso_8859-6'
1889 + | 'iso_8859-7:1987'
1890 + | 'iso_8859-7'
1891 + | 'iso_8859-8:1988'
1892 + | 'iso_8859-8'
1893 + | 'iso_8859-9:1989'
1894 + | 'iso_8859-9'
1895 + | 'iso-2022-cn-ext'
1896 + | 'iso-2022-cn'
1897 + | 'iso-2022-jp'
1898 + | 'iso-2022-kr'
1899 + | 'iso-8859-1'
1900 + | 'iso-8859-10'
1901 + | 'iso-8859-11'
1902 + | 'iso-8859-13'
1903 + | 'iso-8859-14'
1904 + | 'iso-8859-15'
1905 + | 'iso-8859-16'
1906 + | 'iso-8859-2'
1907 + | 'iso-8859-3'
1908 + | 'iso-8859-4'
1909 + | 'iso-8859-5'
1910 + | 'iso-8859-6-e'
1911 + | 'iso-8859-6-i'
1912 + | 'iso-8859-6'
1913 + | 'iso-8859-7'
1914 + | 'iso-8859-8-e'
1915 + | 'iso-8859-8-i'
1916 + | 'iso-8859-8'
1917 + | 'iso-8859-9'
1918 + | 'iso-ir-100'
1919 + | 'iso-ir-101'
1920 + | 'iso-ir-109'
1921 + | 'iso-ir-110'
1922 + | 'iso-ir-126'
1923 + | 'iso-ir-127'
1924 + | 'iso-ir-138'
1925 + | 'iso-ir-144'
1926 + | 'iso-ir-148'
1927 + | 'iso-ir-149'
1928 + | 'iso-ir-157'
1929 + | 'iso-ir-58'
1930 + | 'iso8859-1'
1931 + | 'iso8859-10'
1932 + | 'iso8859-11'
1933 + | 'iso8859-13'
1934 + | 'iso8859-14'
1935 + | 'iso8859-15'
1936 + | 'iso8859-2'
1937 + | 'iso8859-3'
1938 + | 'iso8859-4'
1939 + | 'iso8859-6'
1940 + | 'iso8859-7'
1941 + | 'iso8859-8'
1942 + | 'iso8859-9'
1943 + | 'iso88591'
1944 + | 'iso885910'
1945 + | 'iso885911'
1946 + | 'iso885913'
1947 + | 'iso885914'
1948 + | 'iso885915'
1949 + | 'iso88592'
1950 + | 'iso88593'
1951 + | 'iso88594'
1952 + | 'iso88595'
1953 + | 'iso88596'
1954 + | 'iso88597'
1955 + | 'iso88598'
1956 + | 'iso88599'
1957 + | 'koi'
1958 + | 'koi8_r'
1959 + | 'koi8-r'
1960 + | 'koi8-u'
1961 + | 'koi8'
1962 + | 'korean'
1963 + | 'ks_c_5601-1987'
1964 + | 'ks_c_5601-1989'
1965 + | 'ksc_5601'
1966 + | 'ksc5601'
1967 + | 'l1'
1968 + | 'l2'
1969 + | 'l3'
1970 + | 'l4'
1971 + | 'l5'
1972 + | 'l6'
1973 + | 'l9'
1974 + | 'latin1'
1975 + | 'latin2'
1976 + | 'latin3'
1977 + | 'latin4'
1978 + | 'latin5'
1979 + | 'latin6'
1980 + | 'latin9'
1981 + | 'logical'
1982 + | 'mac'
1983 + | 'macintosh'
1984 + | 'ms_kanji'
1985 + | 'shift_jis'
1986 + | 'shift-jis'
1987 + | 'sjis'
1988 + | 'sun_eu_greek'
1989 + | 'tis-620'
1990 + | 'unicode-1-1-utf-8'
1991 + | 'us-ascii'
1992 + | 'utf-16'
1993 + | 'utf-16be'
1994 + | 'utf-16le'
1995 + | 'utf-8'
1996 + | 'utf8'
1997 + | 'visual'
1998 + | 'windows-1250'
1999 + | 'windows-1251'
2000 + | 'windows-1252'
2001 + | 'windows-1253'
2002 + | 'windows-1254'
2003 + | 'windows-1255'
2004 + | 'windows-1256'
2005 + | 'windows-1257'
2006 + | 'windows-1258'
2007 + | 'windows-31j'
2008 + | 'windows-874'
2009 + | 'windows-949'
2010 + | 'x-cp1250'
2011 + | 'x-cp1251'
2012 + | 'x-cp1252'
2013 + | 'x-cp1253'
2014 + | 'x-cp1254'
2015 + | 'x-cp1255'
2016 + | 'x-cp1256'
2017 + | 'x-cp1257'
2018 + | 'x-cp1258'
2019 + | 'x-euc-jp'
2020 + | 'x-gbk'
2021 + | 'x-mac-cyrillic'
2022 + | 'x-mac-roman'
2023 + | 'x-mac-ukrainian'
2024 + | 'x-sjis'
2025 + | 'x-user-defined'
2026 + | 'x-x-big5';
2027 +
2028 +declare class TextDecoder {
2029 + constructor(
2030 + encoding?: TextDecoder$availableEncodings,
2031 + options?: {fatal: boolean, ...}
2032 + ): void;
2033 + encoding: TextDecoder$availableEncodings;
2034 + fatal: boolean;
2035 + ignoreBOM: boolean;
2036 + decode(
2037 + buffer?: ArrayBuffer | $ArrayBufferView,
2038 + options?: {stream: boolean, ...}
2039 + ): string;
2040 +}
2041 +
2042 +declare class TextDecoderStream {
2043 + constructor(
2044 + encoding?: TextDecoder$availableEncodings,
2045 + options?: {fatal?: boolean, ignoreBOM?: boolean, ...}
2046 + ): void;
2047 + encoding: TextDecoder$availableEncodings;
2048 + fatal: boolean;
2049 + ignoreBOM: boolean;
2050 + readable: ReadableStream;
2051 + writable: WritableStream;
2052 +}
2053 +
2054 +declare class MessagePort extends EventTarget {
2055 + postMessage(message: any, transfer?: Iterable<any>): void;
2056 + start(): void;
2057 + close(): void;
2058 +
2059 + onmessage: null | ((ev: MessageEvent) => mixed);
2060 + onmessageerror: null | ((ev: MessageEvent) => mixed);
2061 +}
2062 +
2063 +declare class MessageChannel {
2064 + port1: MessagePort;
2065 + port2: MessagePort;
2066 +}
2067 +
2068 +declare class VRDisplay extends EventTarget {
2069 + capabilities: VRDisplayCapabilities;
2070 + depthFar: number;
2071 + depthNear: number;
2072 + displayId: number;
2073 + displayName: string;
2074 + isPresenting: boolean;
2075 + stageParameters: null | VRStageParameters;
2076 +
2077 + cancelAnimationFrame(number): void;
2078 + exitPresent(): Promise<void>;
2079 + getEyeParameters(VREye): VREyeParameters;
2080 + getFrameData(VRFrameData): boolean;
2081 + getLayers(): VRLayerInit[];
2082 + requestAnimationFrame(cb: (number) => mixed): number;
2083 + requestPresent(VRLayerInit[]): Promise<void>;
2084 + submitFrame(): void;
2085 +}
2086 +
2087 +type VRSource = HTMLCanvasElement;
2088 +
2089 +type VRLayerInit = {
2090 + leftBounds?: number[],
2091 + rightBounds?: number[],
2092 + source?: null | VRSource,
2093 + ...
2094 +};
2095 +
2096 +type VRDisplayCapabilities = {
2097 + canPresent: boolean,
2098 + hasExternalDisplay: boolean,
2099 + hasPosition: boolean,
2100 + maxLayers: number,
2101 + ...
2102 +};
2103 +
2104 +type VREye = 'left' | 'right';
2105 +
2106 +type VRPose = {
2107 + angularAcceleration?: Float32Array,
2108 + angularVelocity?: Float32Array,
2109 + linearAcceleration?: Float32Array,
2110 + linearVelocity?: Float32Array,
2111 + orientation?: Float32Array,
2112 + position?: Float32Array,
2113 + ...
2114 +};
2115 +
2116 +declare class VRFrameData {
2117 + leftProjectionMatrix: Float32Array;
2118 + leftViewMatrix: Float32Array;
2119 + pose: VRPose;
2120 + rightProjectionMatrix: Float32Array;
2121 + rightViewMatrix: Float32Array;
2122 + timestamp: number;
2123 +}
2124 +
2125 +type VREyeParameters = {
2126 + offset: Float32Array,
2127 + renderWidth: number,
2128 + renderHeight: number,
2129 + ...
2130 +};
2131 +
2132 +type VRStageParameters = {
2133 + sittingToStandingTransform: Float32Array,
2134 + sizeX: number,
2135 + sizeZ: number,
2136 + ...
2137 +};
2138 +
2139 +type VRDisplayEventReason =
2140 + | 'mounted'
2141 + | 'navigation'
2142 + | 'requested'
2143 + | 'unmounted';
2144 +
2145 +type VRDisplayEventInit = {
2146 + display: VRDisplay,
2147 + reason: VRDisplayEventReason,
2148 + ...
2149 +};
2150 +
2151 +declare class VRDisplayEvent extends Event {
2152 + constructor(type: string, eventInitDict: VRDisplayEventInit): void;
2153 + display: VRDisplay;
2154 + reason?: VRDisplayEventReason;
2155 +}
2156 +
2157 +declare class MediaQueryListEvent {
2158 + matches: boolean;
2159 + media: string;
2160 +}
2161 +
2162 +declare type MediaQueryListListener = (MediaQueryListEvent) => void;
2163 +
2164 +declare class MediaQueryList extends EventTarget {
2165 + matches: boolean;
2166 + media: string;
2167 + addListener: MediaQueryListListener => void;
2168 + removeListener: MediaQueryListListener => void;
2169 + onchange: MediaQueryListListener;
2170 +}
2171 +
2172 +declare var matchMedia: string => MediaQueryList;
2173 +
2174 +// https://w3c.github.io/webappsec-credential-management/#idl-index
2175 +declare type CredMgmtCredentialRequestOptions = {
2176 + mediation?: 'silent' | 'optional' | 'required',
2177 + signal?: AbortSignal,
2178 + ...
2179 +};
2180 +
2181 +declare type CredMgmtCredentialCreationOptions = {signal: AbortSignal, ...};
2182 +
2183 +declare interface CredMgmtCredential {
2184 + id: string;
2185 + type: string;
2186 +}
2187 +
2188 +declare interface CredMgmtPasswordCredential extends CredMgmtCredential {
2189 + password: string;
2190 +}
2191 +
2192 +declare interface CredMgmtCredentialsContainer {
2193 + get(option?: CredMgmtCredentialRequestOptions): Promise<?CredMgmtCredential>;
2194 + store(credential: CredMgmtCredential): Promise<CredMgmtCredential>;
2195 + create(
2196 + creationOption?: CredMgmtCredentialCreationOptions
2197 + ): Promise<?CredMgmtCredential>;
2198 + preventSilentAccess(): Promise<void>;
2199 +}
2200 +
2201 +type SpeechSynthesisErrorCode =
2202 + | 'canceled'
2203 + | 'interrupted'
2204 + | 'audio-busy'
2205 + | 'audio-hardware'
2206 + | 'network'
2207 + | 'synthesis-unavailable'
2208 + | 'synthesis-failed'
2209 + | 'language-unavailable'
2210 + | 'voice-unavailable'
2211 + | 'text-too-long'
2212 + | 'invalid-argument'
2213 + | 'not-allowed';
2214 +
2215 +declare class SpeechSynthesis extends EventTarget {
2216 + +pending: boolean;
2217 + +speaking: boolean;
2218 + +paused: boolean;
2219 +
2220 + onvoiceschanged: ?(ev: Event) => mixed;
2221 +
2222 + speak(utterance: SpeechSynthesisUtterance): void;
2223 + cancel(): void;
2224 + pause(): void;
2225 + resume(): void;
2226 + getVoices(): Array<SpeechSynthesisVoice>;
2227 +}
2228 +
2229 +declare var speechSynthesis: SpeechSynthesis;
2230 +
2231 +declare class SpeechSynthesisUtterance extends EventTarget {
2232 + constructor(text?: string): void;
2233 +
2234 + text: string;
2235 + lang: string;
2236 + voice: SpeechSynthesisVoice | null;
2237 + volume: number;
2238 + rate: number;
2239 + pitch: number;
2240 +
2241 + onstart: ?(ev: SpeechSynthesisEvent) => mixed;
2242 + onend: ?(ev: SpeechSynthesisEvent) => mixed;
2243 + onerror: ?(ev: SpeechSynthesisErrorEvent) => mixed;
2244 + onpause: ?(ev: SpeechSynthesisEvent) => mixed;
2245 + onresume: ?(ev: SpeechSynthesisEvent) => mixed;
2246 + onmark: ?(ev: SpeechSynthesisEvent) => mixed;
2247 + onboundary: ?(ev: SpeechSynthesisEvent) => mixed;
2248 +}
2249 +
2250 +type SpeechSynthesisEvent$Init = Event$Init & {
2251 + utterance: SpeechSynthesisUtterance,
2252 + charIndex?: number,
2253 + charLength?: number,
2254 + elapsedTime?: number,
2255 + name?: string,
2256 + ...
2257 +};
2258 +
2259 +declare class SpeechSynthesisEvent extends Event {
2260 + constructor(type: string, eventInitDict?: SpeechSynthesisEvent$Init): void;
2261 +
2262 + +utterance: SpeechSynthesisUtterance;
2263 + charIndex: number;
2264 + charLength: number;
2265 + elapsedTime: number;
2266 + name: string;
2267 +}
2268 +
2269 +type SpeechSynthesisErrorEvent$Init = SpeechSynthesisEvent$Init & {
2270 + error: SpeechSynthesisErrorCode,
2271 + ...
2272 +};
2273 +
2274 +declare class SpeechSynthesisErrorEvent extends SpeechSynthesisEvent {
2275 + constructor(
2276 + type: string,
2277 + eventInitDict?: SpeechSynthesisErrorEvent$Init
2278 + ): void;
2279 + +error: SpeechSynthesisErrorCode;
2280 +}
2281 +
2282 +declare class SpeechSynthesisVoice {
2283 + +voiceURI: string;
2284 + +name: string;
2285 + +lang: string;
2286 + +localService: boolean;
2287 + +default: boolean;
2288 +}
2289 +
2290 +type SpeechRecognitionErrorCode =
2291 + | 'no-speech'
2292 + | 'aborted'
2293 + | 'audio-capture'
2294 + | 'not-allowed'
2295 + | 'service-not-allowed'
2296 + | 'bad-grammar'
2297 + | 'language-not-supported';
2298 +
2299 +declare class SpeechGrammar {
2300 + constructor(): void;
2301 +
2302 + src: string;
2303 + weight?: number;
2304 +}
2305 +
2306 +declare class SpeechGrammarList {
2307 + +length: number;
2308 +
2309 + item(index: number): SpeechGrammar;
2310 + addFromURI(src: string, weight?: number): void;
2311 + addFromString(string: string, weight?: number): void;
2312 +}
2313 +
2314 +declare class SpeechRecognitionAlternative {
2315 + +transcript: string;
2316 + +confidence: number;
2317 +}
2318 +
2319 +declare class SpeechRecognitionResult {
2320 + +isFinal: boolean;
2321 + +length: number;
2322 +
2323 + item(index: number): SpeechRecognitionAlternative;
2324 +}
2325 +
2326 +declare class SpeechRecognitionResultList {
2327 + +length: number;
2328 +
2329 + item(index: number): SpeechRecognitionResult;
2330 +}
2331 +
2332 +type SpeechRecognitionEvent$Init = Event$Init & {
2333 + emma: any,
2334 + interpretation: any,
2335 + resultIndex: number,
2336 + results: SpeechRecognitionResultList,
2337 + ...
2338 +};
2339 +
2340 +declare class SpeechRecognitionEvent extends Event {
2341 + constructor(type: string, eventInitDict?: SpeechRecognitionEvent$Init): void;
2342 +
2343 + +emma: any;
2344 + +interpretation: any;
2345 + +resultIndex: number;
2346 + +results: SpeechRecognitionResultList;
2347 +}
2348 +
2349 +type SpeechRecognitionErrorEvent$Init = SpeechRecognitionEvent$Init & {
2350 + error: SpeechRecognitionErrorCode,
2351 + ...
2352 +};
2353 +
2354 +declare class SpeechRecognitionErrorEvent extends SpeechRecognitionEvent {
2355 + constructor(
2356 + type: string,
2357 + eventInitDict?: SpeechRecognitionErrorEvent$Init
2358 + ): void;
2359 + +error: SpeechRecognitionErrorCode;
2360 + +message: string;
2361 +}
2362 +
2363 +declare class SpeechRecognition extends EventTarget {
2364 + constructor(): void;
2365 +
2366 + +grammars: SpeechGrammar[];
2367 + +lang: string;
2368 + +continuous: boolean;
2369 + +interimResults: boolean;
2370 + +maxAlternatives: number;
2371 + +serviceURI: string;
2372 +
2373 + onaudiostart: ?(ev: Event) => mixed;
2374 + onaudioend: ?(ev: Event) => mixed;
2375 + onend: ?(ev: Event) => mixed;
2376 + onerror: ?(ev: Event) => mixed;
2377 + onnomatch: ?(ev: Event) => mixed;
2378 + onsoundstart: ?(ev: Event) => mixed;
2379 + onsoundend: ?(ev: Event) => mixed;
2380 + onspeechstart: ?(ev: Event) => mixed;
2381 + onspeechend: ?(ev: Event) => mixed;
2382 + onstart: ?(ev: Event) => mixed;
2383 +
2384 + abort(): void;
2385 + start(): void;
2386 + stop(): void;
2387 +}
2388 +
2389 +/* Trusted Types
2390 + * https://w3c.github.io/trusted-types/dist/spec/#trusted-types
2391 + */
2392 +declare class TrustedHTML {
2393 + toString(): string;
2394 + toJSON(): string;
2395 +}
2396 +
2397 +declare class TrustedScript {
2398 + toString(): string;
2399 + toJSON(): string;
2400 +}
2401 +
2402 +declare class TrustedScriptURL {
2403 + toString(): string;
2404 + toJSON(): string;
2405 +}
2406 +
2407 +declare class TrustedTypePolicy {
2408 + +name: string;
2409 + createHTML(input: string, ...args: Array<mixed>): TrustedHTML;
2410 + createScript(input: string, ...args: Array<mixed>): TrustedScript;
2411 + createScriptURL(input: string, ...args: Array<mixed>): TrustedScriptURL;
2412 +}
2413 +
2414 +declare type TrustedTypePolicyOptions = {|
2415 + createHTML?: (string, ...args: Array<mixed>) => string,
2416 + createScript?: (string, ...args: Array<mixed>) => string,
2417 + createScriptURL?: (string, ...args: Array<mixed>) => string,
2418 +|};
2419 +
2420 +// window.trustedTypes?: TrustedTypePolicyFactory
2421 +declare class TrustedTypePolicyFactory {
2422 + +emptyHTML: TrustedHTML;
2423 + +emptyScript: TrustedScript;
2424 + +defaultPolicy: ?TrustedTypePolicy;
2425 + +isHTML: (value: mixed) => value is TrustedHTML;
2426 + +isScript: (value: mixed) => value is TrustedScript;
2427 + +isScriptURL: (value: mixed) => value is TrustedScriptURL;
2428 + createPolicy(
2429 + policyName: string,
2430 + policyOptions?: TrustedTypePolicyOptions
2431 + ): TrustedTypePolicy;
2432 + getAttributeType(
2433 + tagName: string,
2434 + attribute?: string,
2435 + elementNS?: string,
2436 + attrNS?: string
2437 + ): null | string;
2438 + getPropertyType(
2439 + tagName: string,
2440 + property: string,
2441 + elementNS?: string
2442 + ): null | string;
2443 +}
2444 +
2445 +// https://wicg.github.io/webusb/
2446 +// https://developer.mozilla.org/en-US/docs/Web/API/USBDevice
2447 +declare class USBDevice {
2448 + configuration: USBConfiguration;
2449 + configurations: Array<USBConfiguration>;
2450 + deviceClass: number;
2451 + deviceProtocol: number;
2452 + deviceSubclass: number;
2453 + deviceVersionMajor: number;
2454 + deviceVersionMinor: number;
2455 + deviceVersionSubminor: number;
2456 + manufacturerName: ?string;
2457 + opened: boolean;
2458 + productId: number;
2459 + productName: ?string;
2460 + serialNumber: ?string;
2461 + usbVersionMajor: number;
2462 + usbVersionMinor: number;
2463 + usbVersionSubminor: number;
2464 + vendorId: number;
2465 + claimInterface(interfaceNumber: number): Promise<void>;
2466 + clearHalt(direction: 'in' | 'out', endpointNumber: number): Promise<void>;
2467 + close(): Promise<void>;
2468 + controlTransferIn(
2469 + setup: SetUpOptions,
2470 + length: number
2471 + ): Promise<USBInTransferResult>;
2472 + controlTransferOut(
2473 + setup: SetUpOptions,
2474 + data: ArrayBuffer
2475 + ): Promise<USBOutTransferResult>;
2476 + forget(): Promise<void>;
2477 + isochronousTransferIn(
2478 + endpointNumber: number,
2479 + packetLengths: Array<number>
2480 + ): Promise<USBIsochronousInTransferResult>;
2481 + isochronousTransferOut(
2482 + endpointNumber: number,
2483 + data: ArrayBuffer,
2484 + packetLengths: Array<number>
2485 + ): Promise<USBIsochronousOutTransferResult>;
2486 + open(): Promise<void>;
2487 + releaseInterface(interfaceNumber: number): Promise<void>;
2488 + reset(): Promise<void>;
2489 + selectAlternateInterface(
2490 + interfaceNumber: number,
2491 + alternateSetting: number
2492 + ): Promise<void>;
2493 + selectConfiguration(configurationValue: number): Promise<void>;
2494 + transferIn(
2495 + endpointNumber: number,
2496 + length: number
2497 + ): Promise<USBInTransferResult>;
2498 + transferOut(
2499 + endpointNumber: number,
2500 + data: ArrayBuffer
2501 + ): Promise<USBOutTransferResult>;
2502 +}
2503 +
2504 +declare class USB extends EventTarget {
2505 + getDevices(): Promise<Array<USBDevice>>;
2506 + requestDevice(options: USBDeviceRequestOptions): Promise<USBDevice>;
2507 +}
2508 +
2509 +declare type USBDeviceFilter = {|
2510 + vendorId?: number,
2511 + productId?: number,
2512 + classCode?: number,
2513 + subclassCode?: number,
2514 + protocolCode?: number,
2515 + serialNumber?: string,
2516 +|};
2517 +
2518 +declare type USBDeviceRequestOptions = {|
2519 + filters: Array<USBDeviceFilter>,
2520 + exclusionFilters?: Array<USBDeviceFilter>,
2521 +|};
2522 +
2523 +declare class USBConfiguration {
2524 + constructor(): void;
2525 + configurationName: ?string;
2526 + configurationValue: number;
2527 + interfaces: $ReadOnlyArray<USBInterface>;
2528 +}
2529 +
2530 +declare class USBInterface {
2531 + constructor(): void;
2532 + interfaceNumber: number;
2533 + alternate: USBAlternateInterface;
2534 + alternates: Array<USBAlternateInterface>;
2535 + claimed: boolean;
2536 +}
2537 +
2538 +declare class USBAlternateInterface {
2539 + constructor(): void;
2540 + alternateSetting: number;
2541 + interfaceClass: number;
2542 + interfaceSubclass: number;
2543 + interfaceProtocol: number;
2544 + interfaceName: ?string;
2545 + endpoints: Array<USBEndpoint>;
2546 +}
2547 +
2548 +declare class USBEndpoint {
2549 + constructor(): void;
2550 + endpointNumber: number;
2551 + direction: 'in' | 'out';
2552 + type: 'bulk' | 'interrupt' | 'isochronous';
2553 + packetSize: number;
2554 +}
2555 +
2556 +declare class USBOutTransferResult {
2557 + constructor(): void;
2558 + bytesWritten: number;
2559 + status: 'ok' | 'stall';
2560 +}
2561 +
2562 +declare class USBInTransferResult {
2563 + constructor(): void;
2564 + data: DataView;
2565 + status: 'ok' | 'stall' | 'babble';
2566 +}
2567 +
2568 +declare class USBIsochronousInTransferResult {
2569 + constructor(): void;
2570 + data: DataView;
2571 + packets: Array<USBIsochronousInTransferPacket>;
2572 +}
2573 +
2574 +declare class USBIsochronousInTransferPacket {
2575 + constructor(): void;
2576 + data: DataView;
2577 + status: 'ok' | 'stall' | 'babble';
2578 +}
2579 +
2580 +declare class USBIsochronousOutTransferResult {
2581 + constructor(): void;
2582 + packets: Array<USBIsochronousOutTransferPacket>;
2583 +}
2584 +
2585 +declare class USBIsochronousOutTransferPacket {
2586 + constructor(): void;
2587 + bytesWritten: number;
2588 + status: 'ok' | 'stall';
2589 +}
2590 +
2591 +type SetUpOptions = {
2592 + requestType: string,
2593 + recipient: string,
2594 + request: number,
2595 + value: number,
2596 + index: number,
2597 + ...
2598 +};
2599 +
2600 +declare type FileSystemHandleKind = 'file' | 'directory';
2601 +
2602 +// https://wicg.github.io/file-system-access/#api-filesystemhandle
2603 +declare class FileSystemHandle {
2604 + +kind: FileSystemHandleKind;
2605 + +name: string;
2606 +
2607 + isSameEntry: (other: FileSystemHandle) => Promise<boolean>;
2608 + queryPermission?: (
2609 + descriptor: FileSystemHandlePermissionDescriptor
2610 + ) => Promise<PermissionStatus>;
2611 + requestPermission?: (
2612 + descriptor: FileSystemHandlePermissionDescriptor
2613 + ) => Promise<PermissionStatus>;
2614 +}
2615 +
2616 +// https://fs.spec.whatwg.org/#api-filesystemfilehandle
2617 +declare class FileSystemFileHandle extends FileSystemHandle {
2618 + +kind: 'file';
2619 +
2620 + constructor(name: string): void;
2621 +
2622 + getFile(): Promise<File>;
2623 + createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
2624 + createWritable(options?: {|
2625 + keepExistingData?: boolean,
2626 + |}): Promise<FileSystemWritableFileStream>;
2627 +}
2628 +
2629 +// https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle
2630 +declare class FileSystemDirectoryHandle extends FileSystemHandle {
2631 + +kind: 'directory';
2632 +
2633 + constructor(name: string): void;
2634 +
2635 + getDirectoryHandle(
2636 + name: string,
2637 + options?: {|create?: boolean|}
2638 + ): Promise<FileSystemDirectoryHandle>;
2639 + getFileHandle(
2640 + name: string,
2641 + options?: {|create?: boolean|}
2642 + ): Promise<FileSystemFileHandle>;
2643 + removeEntry(name: string, options?: {|recursive?: boolean|}): Promise<void>;
2644 + resolve(possibleDescendant: FileSystemHandle): Promise<Array<string> | null>;
2645 +
2646 + // Async iterator functions
2647 + @@asyncIterator(): AsyncIterator<[string, FileSystemHandle]>;
2648 + entries(): AsyncIterator<[string, FileSystemHandle]>;
2649 + keys(): AsyncIterator<string>;
2650 + values(): AsyncIterator<FileSystemHandle>;
2651 +}
2652 +
2653 +// https://fs.spec.whatwg.org/#api-filesystemsyncaccesshandle
2654 +declare class FileSystemSyncAccessHandle {
2655 + close(): void;
2656 + flush(): void;
2657 + getSize(): number;
2658 + read(buffer: ArrayBuffer, options?: {|at: number|}): number;
2659 + truncate(newSize: number): void;
2660 + write(buffer: ArrayBuffer, options?: {|at: number|}): number;
2661 +}
2662 +
2663 +// https://streams.spec.whatwg.org/#default-writer-class
2664 +declare class WritableStreamDefaultWriter {
2665 + +closed: Promise<void>;
2666 + +desiredSize: number;
2667 + +ready: Promise<void>;
2668 +
2669 + constructor(): void;
2670 +
2671 + abort(reason?: string): Promise<void>;
2672 + close(): Promise<void>;
2673 + releaseLock(): void;
2674 + write(chunk: any): Promise<void>;
2675 +}
2676 +
2677 +// https://streams.spec.whatwg.org/#ws-class
2678 +declare class WriteableStream {
2679 + +locked: boolean;
2680 +
2681 + constructor(): void;
2682 +
2683 + abort(reason: string): Promise<string>;
2684 + close(): Promise<void>;
2685 + getWriter(): WritableStreamDefaultWriter;
2686 +}
2687 +
2688 +// https://fs.spec.whatwg.org/#dictdef-writeparams
2689 +declare type FileSystemWriteableFileStreamDataTypes =
2690 + | ArrayBuffer
2691 + | $TypedArray
2692 + | DataView
2693 + | Blob
2694 + | string;
2695 +
2696 +// https://fs.spec.whatwg.org/#dictdef-writeparams
2697 +declare type FileSystemWriteableFileStreamData =
2698 + | FileSystemWriteableFileStreamDataTypes
2699 + | {|
2700 + type: 'write',
2701 + position?: number,
2702 + data: FileSystemWriteableFileStreamDataTypes,
2703 + |}
2704 + | {|
2705 + type: 'seek',
2706 + position: number,
2707 + data: FileSystemWriteableFileStreamDataTypes,
2708 + |}
2709 + | {|
2710 + type: 'size',
2711 + size: number,
2712 + |};
2713 +
2714 +// https://fs.spec.whatwg.org/#api-filesystemwritablefilestream
2715 +declare class FileSystemWritableFileStream extends WriteableStream {
2716 + write(data: FileSystemWriteableFileStreamData): Promise<void>;
2717 + truncate(size: number): Promise<void>;
2718 + seek(position: number): Promise<void>;
2719 +}
flow-typed/environments/cssom.js new
+414
@@ -0,0 +1,414 @@
1 +// flow-typed signature: ad7b684aa8897ecb82bcc3e009b9fc30
2 +// flow-typed version: 3e51657e95/cssom/flow_>=v0.261.x
3 +
4 +declare class StyleSheet {
5 + disabled: boolean;
6 + +href: string;
7 + +media: MediaList;
8 + +ownerNode: Node;
9 + +parentStyleSheet: ?StyleSheet;
10 + +title: string;
11 + +type: string;
12 +}
13 +
14 +declare class StyleSheetList {
15 + @@iterator(): Iterator<StyleSheet>;
16 + length: number;
17 + [index: number]: StyleSheet;
18 +}
19 +
20 +declare class MediaList {
21 + @@iterator(): Iterator<string>;
22 + mediaText: string;
23 + length: number;
24 + item(index: number): ?string;
25 + deleteMedium(oldMedium: string): void;
26 + appendMedium(newMedium: string): void;
27 + [index: number]: string;
28 +}
29 +
30 +declare class CSSStyleSheet extends StyleSheet {
31 + +cssRules: CSSRuleList;
32 + +ownerRule: ?CSSRule;
33 + deleteRule(index: number): void;
34 + insertRule(rule: string, index: number): number;
35 + replace(text: string): Promise<CSSStyleSheet>;
36 + replaceSync(text: string): void;
37 +}
38 +
39 +declare class CSSGroupingRule extends CSSRule {
40 + +cssRules: CSSRuleList;
41 + deleteRule(index: number): void;
42 + insertRule(rule: string, index: number): number;
43 +}
44 +
45 +declare class CSSConditionRule extends CSSGroupingRule {
46 + conditionText: string;
47 +}
48 +
49 +declare class CSSMediaRule extends CSSConditionRule {
50 + +media: MediaList;
51 +}
52 +
53 +declare class CSSStyleRule extends CSSRule {
54 + selectorText: string;
55 + +style: CSSStyleDeclaration;
56 +}
57 +
58 +declare class CSSSupportsRule extends CSSConditionRule {}
59 +
60 +declare class CSSRule {
61 + cssText: string;
62 + +parentRule: ?CSSRule;
63 + +parentStyleSheet: ?CSSStyleSheet;
64 + +type: number;
65 + static STYLE_RULE: number;
66 + static MEDIA_RULE: number;
67 + static FONT_FACE_RULE: number;
68 + static PAGE_RULE: number;
69 + static IMPORT_RULE: number;
70 + static CHARSET_RULE: number;
71 + static UNKNOWN_RULE: number;
72 + static KEYFRAMES_RULE: number;
73 + static KEYFRAME_RULE: number;
74 + static NAMESPACE_RULE: number;
75 + static COUNTER_STYLE_RULE: number;
76 + static SUPPORTS_RULE: number;
77 + static DOCUMENT_RULE: number;
78 + static FONT_FEATURE_VALUES_RULE: number;
79 + static VIEWPORT_RULE: number;
80 + static REGION_STYLE_RULE: number;
81 +}
82 +
83 +declare class CSSKeyframeRule extends CSSRule {
84 + keyText: string;
85 + +style: CSSStyleDeclaration;
86 +}
87 +
88 +declare class CSSKeyframesRule extends CSSRule {
89 + name: string;
90 + +cssRules: CSSRuleList;
91 + appendRule(rule: string): void;
92 + deleteRule(select: string): void;
93 + findRule(select: string): CSSKeyframeRule | null;
94 +}
95 +
96 +declare class CSSRuleList {
97 + @@iterator(): Iterator<CSSRule>;
98 + length: number;
99 + item(index: number): ?CSSRule;
100 + [index: number]: CSSRule;
101 +}
102 +
103 +declare class CSSStyleDeclaration {
104 + @@iterator(): Iterator<string>;
105 + /* DOM CSS Properties */
106 + alignContent: string;
107 + alignItems: string;
108 + alignSelf: string;
109 + all: string;
110 + animation: string;
111 + animationDelay: string;
112 + animationDirection: string;
113 + animationDuration: string;
114 + animationFillMode: string;
115 + animationIterationCount: string;
116 + animationName: string;
117 + animationPlayState: string;
118 + animationTimingFunction: string;
119 + backdropFilter: string;
120 + webkitBackdropFilter: string;
121 + backfaceVisibility: string;
122 + background: string;
123 + backgroundAttachment: string;
124 + backgroundBlendMode: string;
125 + backgroundClip: string;
126 + backgroundColor: string;
127 + backgroundImage: string;
128 + backgroundOrigin: string;
129 + backgroundPosition: string;
130 + backgroundPositionX: string;
131 + backgroundPositionY: string;
132 + backgroundRepeat: string;
133 + backgroundSize: string;
134 + blockSize: string;
135 + border: string;
136 + borderBlockEnd: string;
137 + borderBlockEndColor: string;
138 + borderBlockEndStyle: string;
139 + borderBlockEndWidth: string;
140 + borderBlockStart: string;
141 + borderBlockStartColor: string;
142 + borderBlockStartStyle: string;
143 + borderBlockStartWidth: string;
144 + borderBottom: string;
145 + borderBottomColor: string;
146 + borderBottomLeftRadius: string;
147 + borderBottomRightRadius: string;
148 + borderBottomStyle: string;
149 + borderBottomWidth: string;
150 + borderCollapse: string;
151 + borderColor: string;
152 + borderImage: string;
153 + borderImageOutset: string;
154 + borderImageRepeat: string;
155 + borderImageSlice: string;
156 + borderImageSource: string;
157 + borderImageWidth: string;
158 + borderInlineEnd: string;
159 + borderInlineEndColor: string;
160 + borderInlineEndStyle: string;
161 + borderInlineEndWidth: string;
162 + borderInlineStart: string;
163 + borderInlineStartColor: string;
164 + borderInlineStartStyle: string;
165 + borderInlineStartWidth: string;
166 + borderLeft: string;
167 + borderLeftColor: string;
168 + borderLeftStyle: string;
169 + borderLeftWidth: string;
170 + borderRadius: string;
171 + borderRight: string;
172 + borderRightColor: string;
173 + borderRightStyle: string;
174 + borderRightWidth: string;
175 + borderSpacing: string;
176 + borderStyle: string;
177 + borderTop: string;
178 + borderTopColor: string;
179 + borderTopLeftRadius: string;
180 + borderTopRightRadius: string;
181 + borderTopStyle: string;
182 + borderTopWidth: string;
183 + borderWidth: string;
184 + bottom: string;
185 + boxDecorationBreak: string;
186 + boxShadow: string;
187 + boxSizing: string;
188 + breakAfter: string;
189 + breakBefore: string;
190 + breakInside: string;
191 + captionSide: string;
192 + clear: string;
193 + clip: string;
194 + clipPath: string;
195 + color: string;
196 + columns: string;
197 + columnCount: string;
198 + columnFill: string;
199 + columnGap: string;
200 + columnRule: string;
201 + columnRuleColor: string;
202 + columnRuleStyle: string;
203 + columnRuleWidth: string;
204 + columnSpan: string;
205 + columnWidth: string;
206 + contain: string;
207 + content: string;
208 + counterIncrement: string;
209 + counterReset: string;
210 + cursor: string;
211 + direction: string;
212 + display: string;
213 + emptyCells: string;
214 + filter: string;
215 + flex: string;
216 + flexBasis: string;
217 + flexDirection: string;
218 + flexFlow: string;
219 + flexGrow: string;
220 + flexShrink: string;
221 + flexWrap: string;
222 + float: string;
223 + font: string;
224 + fontFamily: string;
225 + fontFeatureSettings: string;
226 + fontKerning: string;
227 + fontLanguageOverride: string;
228 + fontSize: string;
229 + fontSizeAdjust: string;
230 + fontStretch: string;
231 + fontStyle: string;
232 + fontSynthesis: string;
233 + fontVariant: string;
234 + fontVariantAlternates: string;
235 + fontVariantCaps: string;
236 + fontVariantEastAsian: string;
237 + fontVariantLigatures: string;
238 + fontVariantNumeric: string;
239 + fontVariantPosition: string;
240 + fontWeight: string;
241 + grad: string;
242 + grid: string;
243 + gridArea: string;
244 + gridAutoColumns: string;
245 + gridAutoFlow: string;
246 + gridAutoPosition: string;
247 + gridAutoRows: string;
248 + gridColumn: string;
249 + gridColumnStart: string;
250 + gridColumnEnd: string;
251 + gridRow: string;
252 + gridRowStart: string;
253 + gridRowEnd: string;
254 + gridTemplate: string;
255 + gridTemplateAreas: string;
256 + gridTemplateRows: string;
257 + gridTemplateColumns: string;
258 + height: string;
259 + hyphens: string;
260 + imageRendering: string;
261 + imageResolution: string;
262 + imageOrientation: string;
263 + imeMode: string;
264 + inherit: string;
265 + initial: string;
266 + inlineSize: string;
267 + isolation: string;
268 + justifyContent: string;
269 + left: string;
270 + letterSpacing: string;
271 + lineBreak: string;
272 + lineHeight: string;
273 + listStyle: string;
274 + listStyleImage: string;
275 + listStylePosition: string;
276 + listStyleType: string;
277 + margin: string;
278 + marginBlockEnd: string;
279 + marginBlockStart: string;
280 + marginBottom: string;
281 + marginInlineEnd: string;
282 + marginInlineStart: string;
283 + marginLeft: string;
284 + marginRight: string;
285 + marginTop: string;
286 + marks: string;
287 + mask: string;
288 + maskType: string;
289 + maxBlockSize: string;
290 + maxHeight: string;
291 + maxInlineSize: string;
292 + maxWidth: string;
293 + minBlockSize: string;
294 + minHeight: string;
295 + minInlineSize: string;
296 + minWidth: string;
297 + mixBlendMode: string;
298 + mozTransform: string;
299 + mozTransformOrigin: string;
300 + mozTransitionDelay: string;
301 + mozTransitionDuration: string;
302 + mozTransitionProperty: string;
303 + mozTransitionTimingFunction: string;
304 + objectFit: string;
305 + objectPosition: string;
306 + offsetBlockEnd: string;
307 + offsetBlockStart: string;
308 + offsetInlineEnd: string;
309 + offsetInlineStart: string;
310 + opacity: string;
311 + order: string;
312 + orphans: string;
313 + outline: string;
314 + outlineColor: string;
315 + outlineOffset: string;
316 + outlineStyle: string;
317 + outlineWidth: string;
318 + overflow: string;
319 + overflowWrap: string;
320 + overflowX: string;
321 + overflowY: string;
322 + padding: string;
323 + paddingBlockEnd: string;
324 + paddingBlockStart: string;
325 + paddingBottom: string;
326 + paddingInlineEnd: string;
327 + paddingInlineStart: string;
328 + paddingLeft: string;
329 + paddingRight: string;
330 + paddingTop: string;
331 + pageBreakAfter: string;
332 + pageBreakBefore: string;
333 + pageBreakInside: string;
334 + perspective: string;
335 + perspectiveOrigin: string;
336 + pointerEvents: string;
337 + position: string;
338 + quotes: string;
339 + rad: string;
340 + resize: string;
341 + right: string;
342 + rubyAlign: string;
343 + rubyMerge: string;
344 + rubyPosition: string;
345 + scrollBehavior: string;
346 + scrollSnapCoordinate: string;
347 + scrollSnapDestination: string;
348 + scrollSnapPointsX: string;
349 + scrollSnapPointsY: string;
350 + scrollSnapType: string;
351 + shapeImageThreshold: string;
352 + shapeMargin: string;
353 + shapeOutside: string;
354 + tableLayout: string;
355 + tabSize: string;
356 + textAlign: string;
357 + textAlignLast: string;
358 + textCombineUpright: string;
359 + textDecoration: string;
360 + textDecorationColor: string;
361 + textDecorationLine: string;
362 + textDecorationStyle: string;
363 + textIndent: string;
364 + textOrientation: string;
365 + textOverflow: string;
366 + textRendering: string;
367 + textShadow: string;
368 + textTransform: string;
369 + textUnderlinePosition: string;
370 + top: string;
371 + touchAction: string;
372 + transform: string;
373 + transformOrigin: string;
374 + transformStyle: string;
375 + transition: string;
376 + transitionDelay: string;
377 + transitionDuration: string;
378 + transitionProperty: string;
379 + transitionTimingFunction: string;
380 + turn: string;
381 + unicodeBidi: string;
382 + unicodeRange: string;
383 + userSelect: string;
384 + verticalAlign: string;
385 + visibility: string;
386 + webkitOverflowScrolling: string;
387 + webkitTransform: string;
388 + webkitTransformOrigin: string;
389 + webkitTransitionDelay: string;
390 + webkitTransitionDuration: string;
391 + webkitTransitionProperty: string;
392 + webkitTransitionTimingFunction: string;
393 + whiteSpace: string;
394 + widows: string;
395 + width: string;
396 + willChange: string;
397 + wordBreak: string;
398 + wordSpacing: string;
399 + wordWrap: string;
400 + writingMode: string;
401 + zIndex: string;
402 +
403 + cssFloat: string;
404 + cssText: string;
405 + getPropertyPriority(property: string): string;
406 + getPropertyValue(property: string): string;
407 + item(index: number): string;
408 + [index: number]: string;
409 + length: number;
410 + parentRule: CSSRule;
411 + removeProperty(property: string): string;
412 + setProperty(property: string, value: ?string, priority: ?string): void;
413 + setPropertyPriority(property: string, priority: string): void;
414 +}
flow-typed/environments/dom.js new
+3676
@@ -0,0 +1,3676 @@
1 +// flow-typed signature: 2872ddd56ba4b4bfefacac38ebdc6087
2 +// flow-typed version: 3e51657e95/dom/flow_>=v0.261.x
3 +
4 +/* Files */
5 +
6 +declare class Blob {
7 + constructor(
8 + blobParts?: Array<any>,
9 + options?: {
10 + type?: string,
11 + endings?: string,
12 + ...
13 + }
14 + ): void;
15 + isClosed: boolean;
16 + size: number;
17 + type: string;
18 + close(): void;
19 + slice(start?: number, end?: number, contentType?: string): Blob;
20 + arrayBuffer(): Promise<ArrayBuffer>;
21 + text(): Promise<string>;
22 + stream(): ReadableStream;
23 +}
24 +
25 +declare class FileReader extends EventTarget {
26 + +EMPTY: 0;
27 + +LOADING: 1;
28 + +DONE: 2;
29 + +error: null | DOMError;
30 + +readyState: 0 | 1 | 2;
31 + +result: null | string | ArrayBuffer;
32 + abort(): void;
33 + onabort: null | ((ev: ProgressEvent) => any);
34 + onerror: null | ((ev: ProgressEvent) => any);
35 + onload: null | ((ev: ProgressEvent) => any);
36 + onloadend: null | ((ev: ProgressEvent) => any);
37 + onloadstart: null | ((ev: ProgressEvent) => any);
38 + onprogress: null | ((ev: ProgressEvent) => any);
39 + readAsArrayBuffer(blob: Blob): void;
40 + readAsBinaryString(blob: Blob): void;
41 + readAsDataURL(blob: Blob): void;
42 + readAsText(blob: Blob, encoding?: string): void;
43 +}
44 +
45 +declare type FilePropertyBag = {
46 + type?: string,
47 + lastModified?: number,
48 + ...
49 +};
50 +declare class File extends Blob {
51 + constructor(
52 + fileBits: $ReadOnlyArray<string | BufferDataSource | Blob>,
53 + filename: string,
54 + options?: FilePropertyBag
55 + ): void;
56 + lastModified: number;
57 + name: string;
58 +}
59 +
60 +declare class FileList {
61 + @@iterator(): Iterator<File>;
62 + length: number;
63 + item(index: number): File;
64 + [index: number]: File;
65 +}
66 +
67 +declare class DOMError {
68 + name: string;
69 +}
70 +
71 +declare interface ShadowRoot extends DocumentFragment {
72 + +delegatesFocus: boolean;
73 + +host: Element;
74 + // flowlint unsafe-getters-setters:off
75 + get innerHTML(): string;
76 + set innerHTML(value: string | TrustedHTML): void;
77 + // flowlint unsafe-getters-setters:error
78 + +mode: ShadowRootMode;
79 +
80 + // From DocumentOrShadowRoot Mixin.
81 + +styleSheets: StyleSheetList;
82 + adoptedStyleSheets: Array<CSSStyleSheet>;
83 +}
84 +
85 +declare type ShadowRootMode = 'open' | 'closed';
86 +
87 +declare type ShadowRootInit = {
88 + delegatesFocus?: boolean,
89 + mode: ShadowRootMode,
90 + ...
91 +};
92 +
93 +declare type ScrollToOptions = {
94 + top?: number,
95 + left?: number,
96 + behavior?: 'auto' | 'smooth',
97 + ...
98 +};
99 +
100 +type EventHandler = (event: Event) => mixed;
101 +type EventListener = {handleEvent: EventHandler, ...} | EventHandler;
102 +type MouseEventHandler = (event: MouseEvent) => mixed;
103 +type MouseEventListener =
104 + | {handleEvent: MouseEventHandler, ...}
105 + | MouseEventHandler;
106 +type FocusEventHandler = (event: FocusEvent) => mixed;
107 +type FocusEventListener =
108 + | {handleEvent: FocusEventHandler, ...}
109 + | FocusEventHandler;
110 +type KeyboardEventHandler = (event: KeyboardEvent) => mixed;
111 +type KeyboardEventListener =
112 + | {handleEvent: KeyboardEventHandler, ...}
113 + | KeyboardEventHandler;
114 +type InputEventHandler = (event: InputEvent) => mixed;
115 +type InputEventListener =
116 + | {handleEvent: InputEventHandler, ...}
117 + | InputEventHandler;
118 +type TouchEventHandler = (event: TouchEvent) => mixed;
119 +type TouchEventListener =
120 + | {handleEvent: TouchEventHandler, ...}
121 + | TouchEventHandler;
122 +type WheelEventHandler = (event: WheelEvent) => mixed;
123 +type WheelEventListener =
124 + | {handleEvent: WheelEventHandler, ...}
125 + | WheelEventHandler;
126 +type AbortProgressEventHandler = (event: ProgressEvent) => mixed;
127 +type AbortProgressEventListener =
128 + | {handleEvent: AbortProgressEventHandler, ...}
129 + | AbortProgressEventHandler;
130 +type ProgressEventHandler = (event: ProgressEvent) => mixed;
131 +type ProgressEventListener =
132 + | {handleEvent: ProgressEventHandler, ...}
133 + | ProgressEventHandler;
134 +type DragEventHandler = (event: DragEvent) => mixed;
135 +type DragEventListener =
136 + | {handleEvent: DragEventHandler, ...}
137 + | DragEventHandler;
138 +type PointerEventHandler = (event: PointerEvent) => mixed;
139 +type PointerEventListener =
140 + | {handleEvent: PointerEventHandler, ...}
141 + | PointerEventHandler;
142 +type AnimationEventHandler = (event: AnimationEvent) => mixed;
143 +type AnimationEventListener =
144 + | {handleEvent: AnimationEventHandler, ...}
145 + | AnimationEventHandler;
146 +type ClipboardEventHandler = (event: ClipboardEvent) => mixed;
147 +type ClipboardEventListener =
148 + | {handleEvent: ClipboardEventHandler, ...}
149 + | ClipboardEventHandler;
150 +type TransitionEventHandler = (event: TransitionEvent) => mixed;
151 +type TransitionEventListener =
152 + | {handleEvent: TransitionEventHandler, ...}
153 + | TransitionEventHandler;
154 +type MessageEventHandler = (event: MessageEvent) => mixed;
155 +type MessageEventListener =
156 + | {handleEvent: MessageEventHandler, ...}
157 + | MessageEventHandler;
158 +type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => mixed;
159 +type BeforeUnloadEventListener =
160 + | {handleEvent: BeforeUnloadEventHandler, ...}
161 + | BeforeUnloadEventHandler;
162 +type StorageEventHandler = (event: StorageEvent) => mixed;
163 +type StorageEventListener =
164 + | {handleEvent: StorageEventHandler, ...}
165 + | StorageEventHandler;
166 +type SecurityPolicyViolationEventHandler = (
167 + event: SecurityPolicyViolationEvent
168 +) => mixed;
169 +type SecurityPolicyViolationEventListener =
170 + | {handleEvent: SecurityPolicyViolationEventHandler, ...}
171 + | SecurityPolicyViolationEventHandler;
172 +type USBConnectionEventHandler = (event: USBConnectionEvent) => mixed;
173 +type USBConnectionEventListener =
174 + | {handleEvent: USBConnectionEventHandler, ...}
175 + | USBConnectionEventHandler;
176 +
177 +type MediaKeySessionType = 'temporary' | 'persistent-license';
178 +type MediaKeyStatus =
179 + | 'usable'
180 + | 'expired'
181 + | 'released'
182 + | 'output-restricted'
183 + | 'output-downscaled'
184 + | 'status-pending'
185 + | 'internal-error';
186 +type MouseEventTypes =
187 + | 'contextmenu'
188 + | 'mousedown'
189 + | 'mouseenter'
190 + | 'mouseleave'
191 + | 'mousemove'
192 + | 'mouseout'
193 + | 'mouseover'
194 + | 'mouseup'
195 + | 'click'
196 + | 'dblclick';
197 +type FocusEventTypes = 'blur' | 'focus' | 'focusin' | 'focusout';
198 +type KeyboardEventTypes = 'keydown' | 'keyup' | 'keypress';
199 +type InputEventTypes = 'input' | 'beforeinput';
200 +type TouchEventTypes = 'touchstart' | 'touchmove' | 'touchend' | 'touchcancel';
201 +type WheelEventTypes = 'wheel';
202 +type AbortProgressEventTypes = 'abort';
203 +type ProgressEventTypes =
204 + | 'abort'
205 + | 'error'
206 + | 'load'
207 + | 'loadend'
208 + | 'loadstart'
209 + | 'progress'
210 + | 'timeout';
211 +type DragEventTypes =
212 + | 'drag'
213 + | 'dragend'
214 + | 'dragenter'
215 + | 'dragexit'
216 + | 'dragleave'
217 + | 'dragover'
218 + | 'dragstart'
219 + | 'drop';
220 +type PointerEventTypes =
221 + | 'pointerover'
222 + | 'pointerenter'
223 + | 'pointerdown'
224 + | 'pointermove'
225 + | 'pointerup'
226 + | 'pointercancel'
227 + | 'pointerout'
228 + | 'pointerleave'
229 + | 'gotpointercapture'
230 + | 'lostpointercapture';
231 +type AnimationEventTypes =
232 + | 'animationstart'
233 + | 'animationend'
234 + | 'animationiteration';
235 +type ClipboardEventTypes = 'clipboardchange' | 'cut' | 'copy' | 'paste';
236 +type TransitionEventTypes =
237 + | 'transitionrun'
238 + | 'transitionstart'
239 + | 'transitionend'
240 + | 'transitioncancel';
241 +type MessageEventTypes = string;
242 +type BeforeUnloadEventTypes = 'beforeunload';
243 +type StorageEventTypes = 'storage';
244 +type SecurityPolicyViolationEventTypes = 'securitypolicyviolation';
245 +type USBConnectionEventTypes = 'connect' | 'disconnect';
246 +type ToggleEventTypes = 'beforetoggle' | 'toggle';
247 +type EventListenerOptionsOrUseCapture =
248 + | boolean
249 + | {
250 + capture?: boolean,
251 + once?: boolean,
252 + passive?: boolean,
253 + signal?: AbortSignal,
254 + ...
255 + };
256 +
257 +declare class EventTarget {
258 + addEventListener(
259 + type: MouseEventTypes,
260 + listener: MouseEventListener,
261 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
262 + ): void;
263 + addEventListener(
264 + type: FocusEventTypes,
265 + listener: FocusEventListener,
266 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
267 + ): void;
268 + addEventListener(
269 + type: KeyboardEventTypes,
270 + listener: KeyboardEventListener,
271 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
272 + ): void;
273 + addEventListener(
274 + type: InputEventTypes,
275 + listener: InputEventListener,
276 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
277 + ): void;
278 + addEventListener(
279 + type: TouchEventTypes,
280 + listener: TouchEventListener,
281 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
282 + ): void;
283 + addEventListener(
284 + type: WheelEventTypes,
285 + listener: WheelEventListener,
286 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
287 + ): void;
288 + addEventListener(
289 + type: AbortProgressEventTypes,
290 + listener: AbortProgressEventListener,
291 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
292 + ): void;
293 + addEventListener(
294 + type: ProgressEventTypes,
295 + listener: ProgressEventListener,
296 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
297 + ): void;
298 + addEventListener(
299 + type: DragEventTypes,
300 + listener: DragEventListener,
301 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
302 + ): void;
303 + addEventListener(
304 + type: PointerEventTypes,
305 + listener: PointerEventListener,
306 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
307 + ): void;
308 + addEventListener(
309 + type: AnimationEventTypes,
310 + listener: AnimationEventListener,
311 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
312 + ): void;
313 + addEventListener(
314 + type: ClipboardEventTypes,
315 + listener: ClipboardEventListener,
316 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
317 + ): void;
318 + addEventListener(
319 + type: TransitionEventTypes,
320 + listener: TransitionEventListener,
321 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
322 + ): void;
323 + addEventListener(
324 + type: MessageEventTypes,
325 + listener: MessageEventListener,
326 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
327 + ): void;
328 + addEventListener(
329 + type: BeforeUnloadEventTypes,
330 + listener: BeforeUnloadEventListener,
331 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
332 + ): void;
333 + addEventListener(
334 + type: StorageEventTypes,
335 + listener: StorageEventListener,
336 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
337 + ): void;
338 + addEventListener(
339 + type: SecurityPolicyViolationEventTypes,
340 + listener: SecurityPolicyViolationEventListener,
341 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
342 + ): void;
343 + addEventListener(
344 + type: USBConnectionEventTypes,
345 + listener: USBConnectionEventListener,
346 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
347 + ): void;
348 + addEventListener(
349 + type: string,
350 + listener: EventListener,
351 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
352 + ): void;
353 +
354 + removeEventListener(
355 + type: MouseEventTypes,
356 + listener: MouseEventListener,
357 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
358 + ): void;
359 + removeEventListener(
360 + type: FocusEventTypes,
361 + listener: FocusEventListener,
362 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
363 + ): void;
364 + removeEventListener(
365 + type: KeyboardEventTypes,
366 + listener: KeyboardEventListener,
367 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
368 + ): void;
369 + removeEventListener(
370 + type: InputEventTypes,
371 + listener: InputEventListener,
372 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
373 + ): void;
374 + removeEventListener(
375 + type: TouchEventTypes,
376 + listener: TouchEventListener,
377 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
378 + ): void;
379 + removeEventListener(
380 + type: WheelEventTypes,
381 + listener: WheelEventListener,
382 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
383 + ): void;
384 + removeEventListener(
385 + type: AbortProgressEventTypes,
386 + listener: AbortProgressEventListener,
387 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
388 + ): void;
389 + removeEventListener(
390 + type: ProgressEventTypes,
391 + listener: ProgressEventListener,
392 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
393 + ): void;
394 + removeEventListener(
395 + type: DragEventTypes,
396 + listener: DragEventListener,
397 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
398 + ): void;
399 + removeEventListener(
400 + type: PointerEventTypes,
401 + listener: PointerEventListener,
402 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
403 + ): void;
404 + removeEventListener(
405 + type: AnimationEventTypes,
406 + listener: AnimationEventListener,
407 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
408 + ): void;
409 + removeEventListener(
410 + type: ClipboardEventTypes,
411 + listener: ClipboardEventListener,
412 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
413 + ): void;
414 + removeEventListener(
415 + type: TransitionEventTypes,
416 + listener: TransitionEventListener,
417 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
418 + ): void;
419 + removeEventListener(
420 + type: MessageEventTypes,
421 + listener: MessageEventListener,
422 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
423 + ): void;
424 + removeEventListener(
425 + type: BeforeUnloadEventTypes,
426 + listener: BeforeUnloadEventListener,
427 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
428 + ): void;
429 + removeEventListener(
430 + type: StorageEventTypes,
431 + listener: StorageEventListener,
432 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
433 + ): void;
434 + removeEventListener(
435 + type: SecurityPolicyViolationEventTypes,
436 + listener: SecurityPolicyViolationEventListener,
437 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
438 + ): void;
439 + removeEventListener(
440 + type: USBConnectionEventTypes,
441 + listener: USBConnectionEventListener,
442 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
443 + ): void;
444 + removeEventListener(
445 + type: string,
446 + listener: EventListener,
447 + optionsOrUseCapture?: EventListenerOptionsOrUseCapture
448 + ): void;
449 +
450 + attachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;
451 + attachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;
452 + attachEvent?: (
453 + type: KeyboardEventTypes,
454 + listener: KeyboardEventListener
455 + ) => void;
456 + attachEvent?: (type: InputEventTypes, listener: InputEventListener) => void;
457 + attachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;
458 + attachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;
459 + attachEvent?: (
460 + type: AbortProgressEventTypes,
461 + listener: AbortProgressEventListener
462 + ) => void;
463 + attachEvent?: (
464 + type: ProgressEventTypes,
465 + listener: ProgressEventListener
466 + ) => void;
467 + attachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;
468 + attachEvent?: (
469 + type: PointerEventTypes,
470 + listener: PointerEventListener
471 + ) => void;
472 + attachEvent?: (
473 + type: AnimationEventTypes,
474 + listener: AnimationEventListener
475 + ) => void;
476 + attachEvent?: (
477 + type: ClipboardEventTypes,
478 + listener: ClipboardEventListener
479 + ) => void;
480 + attachEvent?: (
481 + type: TransitionEventTypes,
482 + listener: TransitionEventListener
483 + ) => void;
484 + attachEvent?: (
485 + type: MessageEventTypes,
486 + listener: MessageEventListener
487 + ) => void;
488 + attachEvent?: (
489 + type: BeforeUnloadEventTypes,
490 + listener: BeforeUnloadEventListener
491 + ) => void;
492 + attachEvent?: (
493 + type: StorageEventTypes,
494 + listener: StorageEventListener
495 + ) => void;
496 + attachEvent?: (
497 + type: USBConnectionEventTypes,
498 + listener: USBConnectionEventListener
499 + ) => void;
500 + attachEvent?: (type: string, listener: EventListener) => void;
501 +
502 + detachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void;
503 + detachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void;
504 + detachEvent?: (
505 + type: KeyboardEventTypes,
506 + listener: KeyboardEventListener
507 + ) => void;
508 + detachEvent?: (type: InputEventTypes, listener: InputEventListener) => void;
509 + detachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void;
510 + detachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void;
511 + detachEvent?: (
512 + type: AbortProgressEventTypes,
513 + listener: AbortProgressEventListener
514 + ) => void;
515 + detachEvent?: (
516 + type: ProgressEventTypes,
517 + listener: ProgressEventListener
518 + ) => void;
519 + detachEvent?: (type: DragEventTypes, listener: DragEventListener) => void;
520 + detachEvent?: (
521 + type: PointerEventTypes,
522 + listener: PointerEventListener
523 + ) => void;
524 + detachEvent?: (
525 + type: AnimationEventTypes,
526 + listener: AnimationEventListener
527 + ) => void;
528 + detachEvent?: (
529 + type: ClipboardEventTypes,
530 + listener: ClipboardEventListener
531 + ) => void;
532 + detachEvent?: (
533 + type: TransitionEventTypes,
534 + listener: TransitionEventListener
535 + ) => void;
536 + detachEvent?: (
537 + type: MessageEventTypes,
538 + listener: MessageEventListener
539 + ) => void;
540 + detachEvent?: (
541 + type: BeforeUnloadEventTypes,
542 + listener: BeforeUnloadEventListener
543 + ) => void;
544 + detachEvent?: (
545 + type: StorageEventTypes,
546 + listener: StorageEventListener
547 + ) => void;
548 + detachEvent?: (
549 + type: USBConnectionEventTypes,
550 + listener: USBConnectionEventListener
551 + ) => void;
552 + detachEvent?: (type: string, listener: EventListener) => void;
553 +
554 + dispatchEvent(evt: Event): boolean;
555 +
556 + // Deprecated
557 +
558 + cancelBubble: boolean;
559 + initEvent(
560 + eventTypeArg: string,
561 + canBubbleArg: boolean,
562 + cancelableArg: boolean
563 + ): void;
564 +}
565 +
566 +// https://dom.spec.whatwg.org/#dictdef-eventinit
567 +type Event$Init = {
568 + bubbles?: boolean,
569 + cancelable?: boolean,
570 + composed?: boolean,
571 + /** Non-standard. See `composed` instead. */
572 + scoped?: boolean,
573 + ...
574 +};
575 +
576 +// https://dom.spec.whatwg.org/#interface-event
577 +declare class Event {
578 + constructor(type: string, eventInitDict?: Event$Init): void;
579 + /**
580 + * Returns the type of event, e.g. "click", "hashchange", or "submit".
581 + */
582 + +type: string;
583 + /**
584 + * Returns the object to which event is dispatched (its target).
585 + */
586 + +target: EventTarget; // TODO: nullable
587 + /** @deprecated */
588 + +srcElement: Element; // TODO: nullable
589 + /**
590 + * Returns the object whose event listener's callback is currently being invoked.
591 + */
592 + +currentTarget: EventTarget; // TODO: nullable
593 + /**
594 + * Returns the invocation target objects of event's path (objects on which
595 + * listeners will be invoked), except for any nodes in shadow trees of which
596 + * the shadow root's mode is "closed" that are not reachable from event's
597 + * currentTarget.
598 + */
599 + composedPath(): Array<EventTarget>;
600 +
601 + +NONE: number;
602 + +AT_TARGET: number;
603 + +BUBBLING_PHASE: number;
604 + +CAPTURING_PHASE: number;
605 + /**
606 + * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET,
607 + * and BUBBLING_PHASE.
608 + */
609 + +eventPhase: number;
610 +
611 + /**
612 + * When dispatched in a tree, invoking this method prevents event from reaching
613 + * any objects other than the current object.
614 + */
615 + stopPropagation(): void;
616 + /**
617 + * Invoking this method prevents event from reaching any registered event
618 + * listeners after the current one finishes running and, when dispatched in a
619 + * tree, also prevents event from reaching any other objects.
620 + */
621 + stopImmediatePropagation(): void;
622 +
623 + /**
624 + * Returns true or false depending on how event was initialized. True if
625 + * event goes through its target's ancestors in reverse tree order, and
626 + * false otherwise.
627 + */
628 + +bubbles: boolean;
629 + /**
630 + * Returns true or false depending on how event was initialized. Its
631 + * return value does not always carry meaning, but true can indicate
632 + * that part of the operation during which event was dispatched, can
633 + * be canceled by invoking the preventDefault() method.
634 + */
635 + +cancelable: boolean;
636 + // returnValue: boolean; // legacy, and some subclasses still define it as a string!
637 + /**
638 + * If invoked when the cancelable attribute value is true, and while
639 + * executing a listener for the event with passive set to false, signals to
640 + * the operation that caused event to be dispatched that it needs to be
641 + * canceled.
642 + */
643 + preventDefault(): void;
644 + /**
645 + * Returns true if preventDefault() was invoked successfully to indicate
646 + * cancelation, and false otherwise.
647 + */
648 + +defaultPrevented: boolean;
649 + /**
650 + * Returns true or false depending on how event was initialized. True if
651 + * event invokes listeners past a ShadowRoot node that is the root of its
652 + * target, and false otherwise.
653 + */
654 + +composed: boolean;
655 +
656 + /**
657 + * Returns true if event was dispatched by the user agent, and false otherwise.
658 + */
659 + +isTrusted: boolean;
660 + /**
661 + * Returns the event's timestamp as the number of milliseconds measured relative
662 + * to the time origin.
663 + */
664 + +timeStamp: number;
665 +
666 + /** Non-standard. See Event.prototype.composedPath */
667 + +deepPath?: () => EventTarget[];
668 + /** Non-standard. See Event.prototype.composed */
669 + +scoped: boolean;
670 +
671 + /**
672 + * @deprecated
673 + */
674 + initEvent(type: string, bubbles: boolean, cancelable: boolean): void;
675 +}
676 +
677 +type CustomEvent$Init = {...Event$Init, detail?: any, ...};
678 +
679 +declare class CustomEvent extends Event {
680 + constructor(type: string, eventInitDict?: CustomEvent$Init): void;
681 + detail: any;
682 +
683 + // deprecated
684 + initCustomEvent(
685 + type: string,
686 + bubbles: boolean,
687 + cancelable: boolean,
688 + detail: any
689 + ): CustomEvent;
690 +}
691 +
692 +type UIEvent$Init = {...Event$Init, detail?: number, view?: any, ...};
693 +
694 +declare class UIEvent extends Event {
695 + constructor(typeArg: string, uiEventInit?: UIEvent$Init): void;
696 + detail: number;
697 + view: any;
698 +}
699 +
700 +declare class CompositionEvent extends UIEvent {
701 + data: string | null;
702 + locale: string;
703 +}
704 +
705 +type MouseEvent$MouseEventInit = {
706 + screenX?: number,
707 + screenY?: number,
708 + clientX?: number,
709 + clientY?: number,
710 + ctrlKey?: boolean,
711 + shiftKey?: boolean,
712 + altKey?: boolean,
713 + metaKey?: boolean,
714 + button?: number,
715 + buttons?: number,
716 + region?: string | null,
717 + relatedTarget?: EventTarget | null,
718 + ...
719 +};
720 +
721 +declare class MouseEvent extends UIEvent {
722 + constructor(
723 + typeArg: string,
724 + mouseEventInit?: MouseEvent$MouseEventInit
725 + ): void;
726 + altKey: boolean;
727 + button: number;
728 + buttons: number;
729 + clientX: number;
730 + clientY: number;
731 + ctrlKey: boolean;
732 + metaKey: boolean;
733 + movementX: number;
734 + movementY: number;
735 + offsetX: number;
736 + offsetY: number;
737 + pageX: number;
738 + pageY: number;
739 + region: string | null;
740 + relatedTarget: EventTarget | null;
741 + screenX: number;
742 + screenY: number;
743 + shiftKey: boolean;
744 + x: number;
745 + y: number;
746 + getModifierState(keyArg: string): boolean;
747 +}
748 +
749 +declare class FocusEvent extends UIEvent {
750 + relatedTarget: ?EventTarget;
751 +}
752 +
753 +type WheelEvent$Init = {
754 + ...MouseEvent$MouseEventInit,
755 + deltaX?: number,
756 + deltaY?: number,
757 + deltaZ?: number,
758 + deltaMode?: 0x00 | 0x01 | 0x02,
759 + ...
760 +};
761 +
762 +declare class WheelEvent extends MouseEvent {
763 + static +DOM_DELTA_PIXEL: 0x00;
764 + static +DOM_DELTA_LINE: 0x01;
765 + static +DOM_DELTA_PAGE: 0x02;
766 +
767 + constructor(type: string, eventInitDict?: WheelEvent$Init): void;
768 + +deltaX: number;
769 + +deltaY: number;
770 + +deltaZ: number;
771 + +deltaMode: 0x00 | 0x01 | 0x02;
772 +}
773 +
774 +declare class DragEvent extends MouseEvent {
775 + dataTransfer: ?DataTransfer; // readonly
776 +}
777 +
778 +type PointerEvent$PointerEventInit = MouseEvent$MouseEventInit & {
779 + pointerId?: number,
780 + width?: number,
781 + height?: number,
782 + pressure?: number,
783 + tangentialPressure?: number,
784 + tiltX?: number,
785 + tiltY?: number,
786 + twist?: number,
787 + pointerType?: string,
788 + isPrimary?: boolean,
789 + ...
790 +};
791 +
792 +declare class PointerEvent extends MouseEvent {
793 + constructor(
794 + typeArg: string,
795 + pointerEventInit?: PointerEvent$PointerEventInit
796 + ): void;
797 + pointerId: number;
798 + width: number;
799 + height: number;
800 + pressure: number;
801 + tangentialPressure: number;
802 + tiltX: number;
803 + tiltY: number;
804 + twist: number;
805 + pointerType: string;
806 + isPrimary: boolean;
807 +}
808 +
809 +declare class ProgressEvent extends Event {
810 + lengthComputable: boolean;
811 + loaded: number;
812 + total: number;
813 +
814 + // Deprecated
815 + initProgressEvent(
816 + typeArg: string,
817 + canBubbleArg: boolean,
818 + cancelableArg: boolean,
819 + lengthComputableArg: boolean,
820 + loadedArg: number,
821 + totalArg: number
822 + ): void;
823 +}
824 +
825 +declare class PromiseRejectionEvent extends Event {
826 + promise: Promise<any>;
827 + reason: any;
828 +}
829 +
830 +type PageTransitionEventInit = {
831 + ...Event$Init,
832 + persisted: boolean,
833 + ...
834 +};
835 +
836 +// https://html.spec.whatwg.org/multipage/browsing-the-web.html#the-pagetransitionevent-interface
837 +declare class PageTransitionEvent extends Event {
838 + constructor(type: string, init?: PageTransitionEventInit): void;
839 + +persisted: boolean;
840 +}
841 +
842 +// used for websockets and postMessage, for example. See:
843 +// https://www.w3.org/TR/2011/WD-websockets-20110419/
844 +// and
845 +// https://www.w3.org/TR/2008/WD-html5-20080610/comms.html
846 +// and
847 +// https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interfaces
848 +declare class MessageEvent extends Event {
849 + data: mixed;
850 + origin: string;
851 + lastEventId: string;
852 + source: WindowProxy;
853 +}
854 +
855 +// https://w3c.github.io/uievents/#idl-keyboardeventinit
856 +type KeyboardEvent$Init = {
857 + ...UIEvent$Init,
858 + /**
859 + * Initializes the `key` attribute of the KeyboardEvent object to the unicode
860 + * character string representing the meaning of a key after taking into
861 + * account all keyboard modifiers (such as shift-state). This value is the
862 + * final effective value of the key. If the key is not a printable character,
863 + * then it should be one of the key values defined in [UIEvents-Key](https://www.w3.org/TR/uievents-key/).
864 + *
865 + * NOTE: not `null`, this results in `evt.key === 'null'`!
866 + */
867 + key?: string | void,
868 + /**
869 + * Initializes the `code` attribute of the KeyboardEvent object to the unicode
870 + * character string representing the key that was pressed, ignoring any
871 + * keyboard modifications such as keyboard layout. This value should be one
872 + * of the code values defined in [UIEvents-Code](https://www.w3.org/TR/uievents-code/).
873 + *
874 + * NOTE: not `null`, this results in `evt.code === 'null'`!
875 + */
876 + code?: string | void,
877 + /**
878 + * Initializes the `location` attribute of the KeyboardEvent object to one of
879 + * the following location numerical constants:
880 + *
881 + * DOM_KEY_LOCATION_STANDARD (numerical value 0)
882 + * DOM_KEY_LOCATION_LEFT (numerical value 1)
883 + * DOM_KEY_LOCATION_RIGHT (numerical value 2)
884 + * DOM_KEY_LOCATION_NUMPAD (numerical value 3)
885 + */
886 + location?: number,
887 + /**
888 + * Initializes the `ctrlKey` attribute of the KeyboardEvent object to true if
889 + * the Control key modifier is to be considered active, false otherwise.
890 + */
891 + ctrlKey?: boolean,
892 + /**
893 + * Initializes the `shiftKey` attribute of the KeyboardEvent object to true if
894 + * the Shift key modifier is to be considered active, false otherwise.
895 + */
896 + shiftKey?: boolean,
897 + /**
898 + * Initializes the `altKey` attribute of the KeyboardEvent object to true if
899 + * the Alt (alternative) (or Option) key modifier is to be considered active,
900 + * false otherwise.
901 + */
902 + altKey?: boolean,
903 + /**
904 + * Initializes the `metaKey` attribute of the KeyboardEvent object to true if
905 + * the Meta key modifier is to be considered active, false otherwise.
906 + */
907 + metaKey?: boolean,
908 + /**
909 + * Initializes the `repeat` attribute of the KeyboardEvent object. This
910 + * attribute should be set to true if the the current KeyboardEvent is
911 + * considered part of a repeating sequence of similar events caused by the
912 + * long depression of any single key, false otherwise.
913 + */
914 + repeat?: boolean,
915 + /**
916 + * Initializes the `isComposing` attribute of the KeyboardEvent object. This
917 + * attribute should be set to true if the event being constructed occurs as
918 + * part of a composition sequence, false otherwise.
919 + */
920 + isComposing?: boolean,
921 + /**
922 + * Initializes the `charCode` attribute of the KeyboardEvent to the Unicode
923 + * code point for the event’s character.
924 + */
925 + charCode?: number,
926 + /**
927 + * Initializes the `keyCode` attribute of the KeyboardEvent to the system-
928 + * and implementation-dependent numerical code signifying the unmodified
929 + * identifier associated with the key pressed.
930 + */
931 + keyCode?: number,
932 + /** Initializes the `which` attribute */
933 + which?: number,
934 + ...
935 +};
936 +
937 +// https://w3c.github.io/uievents/#idl-keyboardevent
938 +declare class KeyboardEvent extends UIEvent {
939 + constructor(typeArg: string, init?: KeyboardEvent$Init): void;
940 +
941 + /** `true` if the Alt (alternative) (or "Option") key modifier was active. */
942 + +altKey: boolean;
943 + /**
944 + * Holds a string that identifies the physical key being pressed. The value
945 + * is not affected by the current keyboard layout or modifier state, so a
946 + * particular key will always return the same value.
947 + */
948 + +code: string;
949 + /** `true` if the Control (control) key modifier was active. */
950 + +ctrlKey: boolean;
951 + /**
952 + * `true` if the key event occurs as part of a composition session, i.e.,
953 + * after a `compositionstart` event and before the corresponding
954 + * `compositionend` event.
955 + */
956 + +isComposing: boolean;
957 + /**
958 + * Holds a [key attribute value](https://www.w3.org/TR/uievents-key/#key-attribute-value)
959 + * corresponding to the key pressed. */
960 + +key: string;
961 + /** An indication of the logical location of the key on the device. */
962 + +location: number;
963 + /** `true` if the meta (Meta) key (or "Command") modifier was active. */
964 + +metaKey: boolean;
965 + /** `true` if the key has been pressed in a sustained manner. */
966 + +repeat: boolean;
967 + /** `true` if the shift (Shift) key modifier was active. */
968 + +shiftKey: boolean;
969 +
970 + /**
971 + * Queries the state of a modifier using a key value.
972 + *
973 + * Returns `true` if it is a modifier key and the modifier is activated,
974 + * `false` otherwise.
975 + */
976 + getModifierState(keyArg?: string): boolean;
977 +
978 + /**
979 + * Holds a character value, for keypress events which generate character
980 + * input. The value is the Unicode reference number (code point) of that
981 + * character (e.g. event.charCode = event.key.charCodeAt(0) for printable
982 + * characters). For keydown or keyup events, the value of charCode is 0.
983 + *
984 + * @deprecated You should use KeyboardEvent.key instead, if available.
985 + */
986 + +charCode: number;
987 + /**
988 + * Holds a system- and implementation-dependent numerical code signifying
989 + * the unmodified identifier associated with the key pressed. Unlike the
990 + * `key` attribute, the set of possible values are not normatively defined.
991 + * Typically, these value of the keyCode SHOULD represent the decimal
992 + * codepoint in ASCII or Windows 1252, but MAY be drawn from a different
993 + * appropriate character set. Implementations that are unable to identify
994 + * a key use the key value 0.
995 + *
996 + * @deprecated You should use KeyboardEvent.key instead, if available.
997 + */
998 + +keyCode: number;
999 + /**
1000 + * Holds a system- and implementation-dependent numerical code signifying
1001 + * the unmodified identifier associated with the key pressed. In most cases,
1002 + * the value is identical to keyCode.
1003 + *
1004 + * @deprecated You should use KeyboardEvent.key instead, if available.
1005 + */
1006 + +which: number;
1007 +}
1008 +
1009 +type InputEvent$Init = {
1010 + ...UIEvent$Init,
1011 + inputType?: string,
1012 + data?: string,
1013 + dataTransfer?: DataTransfer,
1014 + isComposing?: boolean,
1015 + ranges?: Array<any>, // TODO: StaticRange
1016 + ...
1017 +};
1018 +
1019 +declare class InputEvent extends UIEvent {
1020 + constructor(typeArg: string, inputEventInit: InputEvent$Init): void;
1021 + +data: string | null;
1022 + +dataTransfer: DataTransfer | null;
1023 + +inputType: string;
1024 + +isComposing: boolean;
1025 + getTargetRanges(): Array<any>; // TODO: StaticRange
1026 +}
1027 +
1028 +declare class AnimationEvent extends Event {
1029 + animationName: string;
1030 + elapsedTime: number;
1031 + pseudoElement: string;
1032 +
1033 + // deprecated
1034 +
1035 + initAnimationEvent: (
1036 + type: 'animationstart' | 'animationend' | 'animationiteration',
1037 + canBubble: boolean,
1038 + cancelable: boolean,
1039 + animationName: string,
1040 + elapsedTime: number
1041 + ) => void;
1042 +}
1043 +
1044 +// https://www.w3.org/TR/touch-events/#idl-def-Touch
1045 +declare class Touch {
1046 + clientX: number;
1047 + clientY: number;
1048 + identifier: number;
1049 + pageX: number;
1050 + pageY: number;
1051 + screenX: number;
1052 + screenY: number;
1053 + target: EventTarget;
1054 +}
1055 +
1056 +// https://www.w3.org/TR/touch-events/#idl-def-TouchList
1057 +// TouchList#item(index) will return null if n > #length. Should #item's
1058 +// return type just been Touch?
1059 +declare class TouchList {
1060 + @@iterator(): Iterator<Touch>;
1061 + length: number;
1062 + item(index: number): null | Touch;
1063 + [index: number]: Touch;
1064 +}
1065 +
1066 +// https://www.w3.org/TR/touch-events/#touchevent-interface
1067 +declare class TouchEvent extends UIEvent {
1068 + altKey: boolean;
1069 + changedTouches: TouchList;
1070 + ctrlKey: boolean;
1071 + metaKey: boolean;
1072 + shiftKey: boolean;
1073 + targetTouches: TouchList;
1074 + touches: TouchList;
1075 +}
1076 +
1077 +// https://www.w3.org/TR/clipboard-apis/#typedefdef-clipboarditemdata
1078 +// Raw string | Blob are allowed per https://webidl.spec.whatwg.org/#es-promise
1079 +type ClipboardItemData = string | Blob | Promise<string | Blob>;
1080 +
1081 +type PresentationStyle = 'attachment' | 'inline' | 'unspecified';
1082 +
1083 +type ClipboardItemOptions = {
1084 + presentationStyle?: PresentationStyle,
1085 + ...
1086 +};
1087 +
1088 +declare class ClipboardItem {
1089 + +types: $ReadOnlyArray<string>;
1090 + getType(type: string): Promise<Blob>;
1091 + constructor(
1092 + items: {[type: string]: ClipboardItemData},
1093 + options?: ClipboardItemOptions
1094 + ): void;
1095 +}
1096 +
1097 +// https://w3c.github.io/clipboard-apis/ as of 15 May 2018
1098 +type ClipboardEvent$Init = {
1099 + ...Event$Init,
1100 + clipboardData: DataTransfer | null,
1101 + ...
1102 +};
1103 +
1104 +declare class ClipboardEvent extends Event {
1105 + constructor(type: ClipboardEventTypes, eventInit?: ClipboardEvent$Init): void;
1106 + +clipboardData: ?DataTransfer; // readonly
1107 +}
1108 +
1109 +// https://www.w3.org/TR/2017/WD-css-transitions-1-20171130/#interface-transitionevent
1110 +type TransitionEvent$Init = {
1111 + ...Event$Init,
1112 + propertyName: string,
1113 + elapsedTime: number,
1114 + pseudoElement: string,
1115 + ...
1116 +};
1117 +
1118 +declare class TransitionEvent extends Event {
1119 + constructor(
1120 + type: TransitionEventTypes,
1121 + eventInit?: TransitionEvent$Init
1122 + ): void;
1123 +
1124 + +propertyName: string; // readonly
1125 + +elapsedTime: number; // readonly
1126 + +pseudoElement: string; // readonly
1127 +}
1128 +
1129 +declare class SecurityPolicyViolationEvent extends Event {
1130 + +documentURI: string;
1131 + +referrer: string;
1132 + +blockedURI: string;
1133 + +effectiveDirective: string;
1134 + +violatedDirective: string;
1135 + +originalPolicy: string;
1136 + +sourceFile: string;
1137 + +sample: string;
1138 + +disposition: 'enforce' | 'report';
1139 + +statusCode: number;
1140 + +lineNumber: number;
1141 + +columnNumber: number;
1142 +}
1143 +
1144 +// https://developer.mozilla.org/en-US/docs/Web/API/USBConnectionEvent
1145 +declare class USBConnectionEvent extends Event {
1146 + device: USBDevice;
1147 +}
1148 +
1149 +// TODO: *Event
1150 +
1151 +declare class AbortController {
1152 + constructor(): void;
1153 + +signal: AbortSignal;
1154 + abort(reason?: any): void;
1155 +}
1156 +
1157 +declare class AbortSignal extends EventTarget {
1158 + +aborted: boolean;
1159 + +reason: any;
1160 + abort(reason?: any): AbortSignal;
1161 + onabort: (event: Event) => mixed;
1162 + throwIfAborted(): void;
1163 + timeout(time: number): AbortSignal;
1164 +}
1165 +
1166 +declare class Node extends EventTarget {
1167 + baseURI: ?string;
1168 + childNodes: NodeList<Node>;
1169 + firstChild: ?Node;
1170 + +isConnected: boolean;
1171 + lastChild: ?Node;
1172 + nextSibling: ?Node;
1173 + nodeName: string;
1174 + nodeType: number;
1175 + nodeValue: string;
1176 + ownerDocument: Document;
1177 + parentElement: ?Element;
1178 + parentNode: ?Node;
1179 + previousSibling: ?Node;
1180 + rootNode: Node;
1181 + textContent: string;
1182 + appendChild<T: Node>(newChild: T): T;
1183 + cloneNode(deep?: boolean): this;
1184 + compareDocumentPosition(other: Node): number;
1185 + contains(other: ?Node): boolean;
1186 + getRootNode(options?: {composed: boolean, ...}): Node;
1187 + hasChildNodes(): boolean;
1188 + insertBefore<T: Node>(newChild: T, refChild?: ?Node): T;
1189 + isDefaultNamespace(namespaceURI: string): boolean;
1190 + isEqualNode(arg: Node): boolean;
1191 + isSameNode(other: Node): boolean;
1192 + lookupNamespaceURI(prefix: string): string;
1193 + lookupPrefix(namespaceURI: string): string;
1194 + normalize(): void;
1195 + removeChild<T: Node>(oldChild: T): T;
1196 + replaceChild<T: Node>(newChild: Node, oldChild: T): T;
1197 + replaceChildren(...nodes: $ReadOnlyArray<Node | string>): void;
1198 + static ATTRIBUTE_NODE: number;
1199 + static CDATA_SECTION_NODE: number;
1200 + static COMMENT_NODE: number;
1201 + static DOCUMENT_FRAGMENT_NODE: number;
1202 + static DOCUMENT_NODE: number;
1203 + static DOCUMENT_POSITION_CONTAINED_BY: number;
1204 + static DOCUMENT_POSITION_CONTAINS: number;
1205 + static DOCUMENT_POSITION_DISCONNECTED: number;
1206 + static DOCUMENT_POSITION_FOLLOWING: number;
1207 + static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
1208 + static DOCUMENT_POSITION_PRECEDING: number;
1209 + static DOCUMENT_TYPE_NODE: number;
1210 + static ELEMENT_NODE: number;
1211 + static ENTITY_NODE: number;
1212 + static ENTITY_REFERENCE_NODE: number;
1213 + static NOTATION_NODE: number;
1214 + static PROCESSING_INSTRUCTION_NODE: number;
1215 + static TEXT_NODE: number;
1216 +
1217 + // Non-standard
1218 + innerText?: string;
1219 + outerText?: string;
1220 +}
1221 +
1222 +declare class NodeList<T> {
1223 + @@iterator(): Iterator<T>;
1224 + length: number;
1225 + item(index: number): T;
1226 + [index: number]: T;
1227 +
1228 + forEach<This>(
1229 + callbackfn: (this: This, value: T, index: number, list: NodeList<T>) => any,
1230 + thisArg: This
1231 + ): void;
1232 + entries(): Iterator<[number, T]>;
1233 + keys(): Iterator<number>;
1234 + values(): Iterator<T>;
1235 +}
1236 +
1237 +declare class NamedNodeMap {
1238 + @@iterator(): Iterator<Attr>;
1239 + length: number;
1240 + removeNamedItemNS(namespaceURI: string, localName: string): Attr;
1241 + item(index: number): Attr;
1242 + [index: number | string]: Attr;
1243 + removeNamedItem(name: string): Attr;
1244 + getNamedItem(name: string): Attr;
1245 + setNamedItem(arg: Attr): Attr;
1246 + getNamedItemNS(namespaceURI: string, localName: string): Attr;
1247 + setNamedItemNS(arg: Attr): Attr;
1248 +}
1249 +
1250 +declare class Attr extends Node {
1251 + isId: boolean;
1252 + specified: boolean;
1253 + ownerElement: Element | null;
1254 + value: string;
1255 + name: string;
1256 + namespaceURI: string | null;
1257 + prefix: string | null;
1258 + localName: string;
1259 +}
1260 +
1261 +declare class HTMLCollection<+Elem: Element> {
1262 + @@iterator(): Iterator<Elem>;
1263 + length: number;
1264 + item(nameOrIndex?: any, optionalIndex?: any): Elem | null;
1265 + namedItem(name: string): Elem | null;
1266 + [index: number | string]: Elem;
1267 +}
1268 +
1269 +// from https://www.w3.org/TR/custom-elements/#extensions-to-document-interface-to-register
1270 +// See also https://github.com/w3c/webcomponents/
1271 +type ElementRegistrationOptions = {
1272 + +prototype?: {
1273 + // from https://www.w3.org/TR/custom-elements/#types-of-callbacks
1274 + // See also https://github.com/w3c/webcomponents/
1275 + +createdCallback?: () => mixed,
1276 + +attachedCallback?: () => mixed,
1277 + +detachedCallback?: () => mixed,
1278 + +attributeChangedCallback?: ((
1279 + // attribute is set
1280 + attributeLocalName: string,
1281 + oldAttributeValue: null,
1282 + newAttributeValue: string,
1283 + attributeNamespace: string
1284 + ) => mixed) &
1285 + // attribute is changed
1286 + ((
1287 + attributeLocalName: string,
1288 + oldAttributeValue: string,
1289 + newAttributeValue: string,
1290 + attributeNamespace: string
1291 + ) => mixed) &
1292 + // attribute is removed
1293 + ((
1294 + attributeLocalName: string,
1295 + oldAttributeValue: string,
1296 + newAttributeValue: null,
1297 + attributeNamespace: string
1298 + ) => mixed),
1299 + ...
1300 + },
1301 + +extends?: string,
1302 + ...
1303 +};
1304 +
1305 +type ElementCreationOptions = {is: string, ...};
1306 +
1307 +declare class MutationRecord {
1308 + type: 'attributes' | 'characterData' | 'childList';
1309 + target: Node;
1310 + addedNodes: NodeList<Node>;
1311 + removedNodes: NodeList<Node>;
1312 + previousSibling: ?Node;
1313 + nextSibling: ?Node;
1314 + attributeName: ?string;
1315 + attributeNamespace: ?string;
1316 + oldValue: ?string;
1317 +}
1318 +
1319 +type MutationObserverInitRequired =
1320 + | {childList: true, ...}
1321 + | {attributes: true, ...}
1322 + | {characterData: true, ...};
1323 +
1324 +declare type MutationObserverInit = MutationObserverInitRequired & {
1325 + subtree?: boolean,
1326 + attributeOldValue?: boolean,
1327 + characterDataOldValue?: boolean,
1328 + attributeFilter?: Array<string>,
1329 + ...
1330 +};
1331 +
1332 +declare class MutationObserver {
1333 + constructor(
1334 + callback: (arr: Array<MutationRecord>, observer: MutationObserver) => mixed
1335 + ): void;
1336 + observe(target: Node, options: MutationObserverInit): void;
1337 + takeRecords(): Array<MutationRecord>;
1338 + disconnect(): void;
1339 +}
1340 +
1341 +declare class Document extends Node {
1342 + +timeline: DocumentTimeline;
1343 + getAnimations(): Array<Animation>;
1344 + +URL: string;
1345 + adoptNode<T: Node>(source: T): T;
1346 + anchors: HTMLCollection<HTMLAnchorElement>;
1347 + applets: HTMLCollection<HTMLAppletElement>;
1348 + body: HTMLBodyElement | null;
1349 + +characterSet: string;
1350 + /**
1351 + * Legacy alias of `characterSet`
1352 + * @deprecated
1353 + */
1354 + +charset: string;
1355 + close(): void;
1356 + +contentType: string;
1357 + cookie: string;
1358 + createAttribute(name: string): Attr;
1359 + createAttributeNS(namespaceURI: string | null, qualifiedName: string): Attr;
1360 + createCDATASection(data: string): Text;
1361 + createComment(data: string): Comment;
1362 + createDocumentFragment(): DocumentFragment;
1363 + createElement<TName: $Keys<HTMLElementTagNameMap>>(
1364 + localName: TName,
1365 + options?: string | ElementCreationOptions
1366 + ): HTMLElementTagNameMap[TName];
1367 + createElementNS<TName: $Keys<HTMLElementTagNameMap>>(
1368 + namespaceURI: 'http://www.w3.org/1999/xhtml',
1369 + qualifiedName: TName,
1370 + options?: string | ElementCreationOptions
1371 + ): HTMLElementTagNameMap[TName];
1372 + createElementNS(
1373 + namespaceURI: string | null,
1374 + qualifiedName: string,
1375 + options?: string | ElementCreationOptions
1376 + ): Element;
1377 + createTextNode(data: string): Text;
1378 + currentScript: HTMLScriptElement | null;
1379 + dir: 'rtl' | 'ltr';
1380 + +doctype: DocumentType | null;
1381 + +documentElement: HTMLElement | null;
1382 + documentMode: number;
1383 + +documentURI: string;
1384 + domain: string | null;
1385 + embeds: HTMLCollection<HTMLEmbedElement>;
1386 + exitFullscreen(): Promise<void>;
1387 + queryCommandSupported(cmdID: string): boolean;
1388 + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
1389 + forms: HTMLCollection<HTMLFormElement>;
1390 + fullscreenElement: Element | null;
1391 + fullscreenEnabled: boolean;
1392 + getElementsByClassName(classNames: string): HTMLCollection<HTMLElement>;
1393 + getElementsByName(elementName: string): HTMLCollection<HTMLElement>;
1394 + getElementsByTagName<TName: $Keys<HTMLElementTagNameMap>>(
1395 + qualifiedName: TName
1396 + ): HTMLCollection<HTMLElementTagNameMap[TName]>;
1397 + getElementsByTagNameNS<TName: $Keys<HTMLElementTagNameMap>>(
1398 + namespaceURI: 'http://www.w3.org/1999/xhtml',
1399 + qualifiedName: TName
1400 + ): HTMLCollection<HTMLElementTagNameMap[TName]>;
1401 + getElementsByTagNameNS(
1402 + namespaceURI: string | null,
1403 + qualifiedName: string
1404 + ): HTMLCollection<Element>;
1405 + head: HTMLHeadElement | null;
1406 + images: HTMLCollection<HTMLImageElement>;
1407 + +implementation: DOMImplementation;
1408 + importNode<T: Node>(importedNode: T, deep: boolean): T;
1409 + /**
1410 + * Legacy alias of `characterSet`
1411 + * @deprecated
1412 + */
1413 + +inputEncoding: string;
1414 + lastModified: string;
1415 + links: HTMLCollection<HTMLLinkElement>;
1416 + media: string;
1417 + open(url?: string, name?: string, features?: string, replace?: boolean): any;
1418 + readyState: string;
1419 + referrer: string;
1420 + scripts: HTMLCollection<HTMLScriptElement>;
1421 + scrollingElement: HTMLElement | null;
1422 + title: string;
1423 + visibilityState: 'visible' | 'hidden' | 'prerender' | 'unloaded';
1424 + write(...content: Array<string | TrustedHTML>): void;
1425 + writeln(...content: Array<string | TrustedHTML>): void;
1426 + xmlEncoding: string;
1427 + xmlStandalone: boolean;
1428 + xmlVersion: string;
1429 +
1430 + registerElement(type: string, options?: ElementRegistrationOptions): any;
1431 + getSelection(): Selection | null;
1432 +
1433 + // 6.4.6 Focus management APIs
1434 + activeElement: HTMLElement | null;
1435 + hasFocus(): boolean;
1436 +
1437 + // extension
1438 + location: Location;
1439 + createEvent(eventInterface: 'CustomEvent'): CustomEvent;
1440 + createEvent(eventInterface: string): Event;
1441 + createRange(): Range;
1442 + elementFromPoint(x: number, y: number): HTMLElement | null;
1443 + elementsFromPoint(x: number, y: number): Array<HTMLElement>;
1444 + defaultView: any;
1445 + +compatMode: 'BackCompat' | 'CSS1Compat';
1446 + hidden: boolean;
1447 +
1448 + // Pointer Lock specification
1449 + exitPointerLock(): void;
1450 + pointerLockElement: Element | null;
1451 +
1452 + // from ParentNode interface
1453 + childElementCount: number;
1454 + children: HTMLCollection<HTMLElement>;
1455 + firstElementChild: ?Element;
1456 + lastElementChild: ?Element;
1457 + append(...nodes: Array<string | Node>): void;
1458 + prepend(...nodes: Array<string | Node>): void;
1459 +
1460 + querySelector<TSelector: $Keys<HTMLElementTagNameMap>>(
1461 + selector: TSelector
1462 + ): HTMLElementTagNameMap[TSelector] | null;
1463 + querySelectorAll<TSelector: $Keys<HTMLElementTagNameMap>>(
1464 + selector: TSelector
1465 + ): NodeList<HTMLElementTagNameMap[TSelector]>;
1466 + // Interface DocumentTraversal
1467 + // http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113/traversal.html#Traversal-Document
1468 +
1469 + // Not all combinations of RootNodeT and whatToShow are logically possible.
1470 + // The bitmasks NodeFilter.SHOW_CDATA_SECTION,
1471 + // NodeFilter.SHOW_ENTITY_REFERENCE, NodeFilter.SHOW_ENTITY, and
1472 + // NodeFilter.SHOW_NOTATION are deprecated and do not correspond to types
1473 + // that Flow knows about.
1474 +
1475 + // NodeFilter.SHOW_ATTRIBUTE is also deprecated, but corresponds to the
1476 + // type Attr. While there is no reason to prefer it to Node.attributes,
1477 + // it does have meaning and can be typed: When (whatToShow &
1478 + // NodeFilter.SHOW_ATTRIBUTE === 1), RootNodeT must be Attr, and when
1479 + // RootNodeT is Attr, bitmasks other than NodeFilter.SHOW_ATTRIBUTE are
1480 + // meaningless.
1481 + createNodeIterator<RootNodeT: Attr>(
1482 + root: RootNodeT,
1483 + whatToShow: 2,
1484 + filter?: NodeFilterInterface
1485 + ): NodeIterator<RootNodeT, Attr>;
1486 + createTreeWalker<RootNodeT: Attr>(
1487 + root: RootNodeT,
1488 + whatToShow: 2,
1489 + filter?: NodeFilterInterface,
1490 + entityReferenceExpansion?: boolean
1491 + ): TreeWalker<RootNodeT, Attr>;
1492 +
1493 + // NodeFilter.SHOW_PROCESSING_INSTRUCTION is not implemented because Flow
1494 + // does not currently define a ProcessingInstruction class.
1495 +
1496 + // When (whatToShow & NodeFilter.SHOW_DOCUMENT === 1 || whatToShow &
1497 + // NodeFilter.SHOW_DOCUMENT_TYPE === 1), RootNodeT must be Document.
1498 + createNodeIterator<RootNodeT: Document>(
1499 + root: RootNodeT,
1500 + whatToShow: 256,
1501 + filter?: NodeFilterInterface
1502 + ): NodeIterator<RootNodeT, Document>;
1503 + createNodeIterator<RootNodeT: Document>(
1504 + root: RootNodeT,
1505 + whatToShow: 257,
1506 + filter?: NodeFilterInterface
1507 + ): NodeIterator<RootNodeT, Document | Element>;
1508 + createNodeIterator<RootNodeT: Document>(
1509 + root: RootNodeT,
1510 + whatToShow: 260,
1511 + filter?: NodeFilterInterface
1512 + ): NodeIterator<RootNodeT, Document | Text>;
1513 + createNodeIterator<RootNodeT: Document>(
1514 + root: RootNodeT,
1515 + whatToShow: 261,
1516 + filter?: NodeFilterInterface
1517 + ): NodeIterator<RootNodeT, Document | Element | Text>;
1518 + createNodeIterator<RootNodeT: Document>(
1519 + root: RootNodeT,
1520 + whatToShow: 384,
1521 + filter?: NodeFilterInterface
1522 + ): NodeIterator<RootNodeT, Document | Comment>;
1523 + createNodeIterator<RootNodeT: Document>(
1524 + root: RootNodeT,
1525 + whatToShow: 385,
1526 + filter?: NodeFilterInterface
1527 + ): NodeIterator<RootNodeT, Document | Element | Comment>;
1528 + createNodeIterator<RootNodeT: Document>(
1529 + root: RootNodeT,
1530 + whatToShow: 388,
1531 + filter?: NodeFilterInterface
1532 + ): NodeIterator<RootNodeT, Document | Text | Comment>;
1533 + createNodeIterator<RootNodeT: Document>(
1534 + root: RootNodeT,
1535 + whatToShow: 389,
1536 + filter?: NodeFilterInterface
1537 + ): NodeIterator<RootNodeT, Document | Element | Text | Comment>;
1538 + createNodeIterator<RootNodeT: Document>(
1539 + root: RootNodeT,
1540 + whatToShow: 512,
1541 + filter?: NodeFilterInterface
1542 + ): NodeIterator<RootNodeT, DocumentType>;
1543 + createNodeIterator<RootNodeT: Document>(
1544 + root: RootNodeT,
1545 + whatToShow: 513,
1546 + filter?: NodeFilterInterface
1547 + ): NodeIterator<RootNodeT, DocumentType | Element>;
1548 + createNodeIterator<RootNodeT: Document>(
1549 + root: RootNodeT,
1550 + whatToShow: 516,
1551 + filter?: NodeFilterInterface
1552 + ): NodeIterator<RootNodeT, DocumentType | Text>;
1553 + createNodeIterator<RootNodeT: Document>(
1554 + root: RootNodeT,
1555 + whatToShow: 517,
1556 + filter?: NodeFilterInterface
1557 + ): NodeIterator<RootNodeT, DocumentType | Element | Text>;
1558 + createNodeIterator<RootNodeT: Document>(
1559 + root: RootNodeT,
1560 + whatToShow: 640,
1561 + filter?: NodeFilterInterface
1562 + ): NodeIterator<RootNodeT, DocumentType | Comment>;
1563 + createNodeIterator<RootNodeT: Document>(
1564 + root: RootNodeT,
1565 + whatToShow: 641,
1566 + filter?: NodeFilterInterface
1567 + ): NodeIterator<RootNodeT, DocumentType | Element | Comment>;
1568 + createNodeIterator<RootNodeT: Document>(
1569 + root: RootNodeT,
1570 + whatToShow: 644,
1571 + filter?: NodeFilterInterface
1572 + ): NodeIterator<RootNodeT, DocumentType | Text | Comment>;
1573 + createNodeIterator<RootNodeT: Document>(
1574 + root: RootNodeT,
1575 + whatToShow: 645,
1576 + filter?: NodeFilterInterface
1577 + ): NodeIterator<RootNodeT, DocumentType | Element | Text | Comment>;
1578 + createNodeIterator<RootNodeT: Document>(
1579 + root: RootNodeT,
1580 + whatToShow: 768,
1581 + filter?: NodeFilterInterface
1582 + ): NodeIterator<RootNodeT, DocumentType | Document>;
1583 + createNodeIterator<RootNodeT: Document>(
1584 + root: RootNodeT,
1585 + whatToShow: 769,
1586 + filter?: NodeFilterInterface
1587 + ): NodeIterator<RootNodeT, DocumentType | Document | Element>;
1588 + createNodeIterator<RootNodeT: Document>(
1589 + root: RootNodeT,
1590 + whatToShow: 772,
1591 + filter?: NodeFilterInterface
1592 + ): NodeIterator<RootNodeT, DocumentType | Document | Text>;
1593 + createNodeIterator<RootNodeT: Document>(
1594 + root: RootNodeT,
1595 + whatToShow: 773,
1596 + filter?: NodeFilterInterface
1597 + ): NodeIterator<RootNodeT, DocumentType | Document | Element | Text>;
1598 + createNodeIterator<RootNodeT: Document>(
1599 + root: RootNodeT,
1600 + whatToShow: 896,
1601 + filter?: NodeFilterInterface
1602 + ): NodeIterator<RootNodeT, DocumentType | Document | Comment>;
1603 + createNodeIterator<RootNodeT: Document>(
1604 + root: RootNodeT,
1605 + whatToShow: 897,
1606 + filter?: NodeFilterInterface
1607 + ): NodeIterator<RootNodeT, DocumentType | Document | Element | Comment>;
1608 + createNodeIterator<RootNodeT: Document>(
1609 + root: RootNodeT,
1610 + whatToShow: 900,
1611 + filter?: NodeFilterInterface
1612 + ): NodeIterator<RootNodeT, DocumentType | Document | Text | Comment>;
1613 + createNodeIterator<RootNodeT: Document>(
1614 + root: RootNodeT,
1615 + whatToShow: 901,
1616 + filter?: NodeFilterInterface
1617 + ): NodeIterator<
1618 + RootNodeT,
1619 + DocumentType | Document | Element | Text | Comment,
1620 + >;
1621 + createTreeWalker<RootNodeT: Document>(
1622 + root: RootNodeT,
1623 + whatToShow: 256,
1624 + filter?: NodeFilterInterface,
1625 + entityReferenceExpansion?: boolean
1626 + ): TreeWalker<RootNodeT, Document>;
1627 + createTreeWalker<RootNodeT: Document>(
1628 + root: RootNodeT,
1629 + whatToShow: 257,
1630 + filter?: NodeFilterInterface,
1631 + entityReferenceExpansion?: boolean
1632 + ): TreeWalker<RootNodeT, Document | Element>;
1633 + createTreeWalker<RootNodeT: Document>(
1634 + root: RootNodeT,
1635 + whatToShow: 260,
1636 + filter?: NodeFilterInterface,
1637 + entityReferenceExpansion?: boolean
1638 + ): TreeWalker<RootNodeT, Document | Text>;
1639 + createTreeWalker<RootNodeT: Document>(
1640 + root: RootNodeT,
1641 + whatToShow: 261,
1642 + filter?: NodeFilterInterface,
1643 + entityReferenceExpansion?: boolean
1644 + ): TreeWalker<RootNodeT, Document | Element | Text>;
1645 + createTreeWalker<RootNodeT: Document>(
1646 + root: RootNodeT,
1647 + whatToShow: 384,
1648 + filter?: NodeFilterInterface,
1649 + entityReferenceExpansion?: boolean
1650 + ): TreeWalker<RootNodeT, Document | Comment>;
1651 + createTreeWalker<RootNodeT: Document>(
1652 + root: RootNodeT,
1653 + whatToShow: 385,
1654 + filter?: NodeFilterInterface,
1655 + entityReferenceExpansion?: boolean
1656 + ): TreeWalker<RootNodeT, Document | Element | Comment>;
1657 + createTreeWalker<RootNodeT: Document>(
1658 + root: RootNodeT,
1659 + whatToShow: 388,
1660 + filter?: NodeFilterInterface,
1661 + entityReferenceExpansion?: boolean
1662 + ): TreeWalker<RootNodeT, Document | Text | Comment>;
1663 + createTreeWalker<RootNodeT: Document>(
1664 + root: RootNodeT,
1665 + whatToShow: 389,
1666 + filter?: NodeFilterInterface,
1667 + entityReferenceExpansion?: boolean
1668 + ): TreeWalker<RootNodeT, Document | Element | Text | Comment>;
1669 + createTreeWalker<RootNodeT: Document>(
1670 + root: RootNodeT,
1671 + whatToShow: 512,
1672 + filter?: NodeFilterInterface,
1673 + entityReferenceExpansion?: boolean
1674 + ): TreeWalker<RootNodeT, DocumentType>;
1675 + createTreeWalker<RootNodeT: Document>(
1676 + root: RootNodeT,
1677 + whatToShow: 513,
1678 + filter?: NodeFilterInterface,
1679 + entityReferenceExpansion?: boolean
1680 + ): TreeWalker<RootNodeT, DocumentType | Element>;
1681 + createTreeWalker<RootNodeT: Document>(
1682 + root: RootNodeT,
1683 + whatToShow: 516,
1684 + filter?: NodeFilterInterface,
1685 + entityReferenceExpansion?: boolean
1686 + ): TreeWalker<RootNodeT, DocumentType | Text>;
1687 + createTreeWalker<RootNodeT: Document>(
1688 + root: RootNodeT,
1689 + whatToShow: 517,
1690 + filter?: NodeFilterInterface,
1691 + entityReferenceExpansion?: boolean
1692 + ): TreeWalker<RootNodeT, DocumentType | Element | Text>;
1693 + createTreeWalker<RootNodeT: Document>(
1694 + root: RootNodeT,
1695 + whatToShow: 640,
1696 + filter?: NodeFilterInterface,
1697 + entityReferenceExpansion?: boolean
1698 + ): TreeWalker<RootNodeT, DocumentType | Comment>;
1699 + createTreeWalker<RootNodeT: Document>(
1700 + root: RootNodeT,
1701 + whatToShow: 641,
1702 + filter?: NodeFilterInterface,
1703 + entityReferenceExpansion?: boolean
1704 + ): TreeWalker<RootNodeT, DocumentType | Element | Comment>;
1705 + createTreeWalker<RootNodeT: Document>(
1706 + root: RootNodeT,
1707 + whatToShow: 644,
1708 + filter?: NodeFilterInterface,
1709 + entityReferenceExpansion?: boolean
1710 + ): TreeWalker<RootNodeT, DocumentType | Text | Comment>;
1711 + createTreeWalker<RootNodeT: Document>(
1712 + root: RootNodeT,
1713 + whatToShow: 645,
1714 + filter?: NodeFilterInterface,
1715 + entityReferenceExpansion?: boolean
1716 + ): TreeWalker<RootNodeT, DocumentType | Element | Text | Comment>;
1717 + createTreeWalker<RootNodeT: Document>(
1718 + root: RootNodeT,
1719 + whatToShow: 768,
1720 + filter?: NodeFilterInterface,
1721 + entityReferenceExpansion?: boolean
1722 + ): TreeWalker<RootNodeT, DocumentType | Document>;
1723 + createTreeWalker<RootNodeT: Document>(
1724 + root: RootNodeT,
1725 + whatToShow: 769,
1726 + filter?: NodeFilterInterface,
1727 + entityReferenceExpansion?: boolean
1728 + ): TreeWalker<RootNodeT, DocumentType | Document | Element>;
1729 + createTreeWalker<RootNodeT: Document>(
1730 + root: RootNodeT,
1731 + whatToShow: 772,
1732 + filter?: NodeFilterInterface,
1733 + entityReferenceExpansion?: boolean
1734 + ): TreeWalker<RootNodeT, DocumentType | Document | Text>;
1735 + createTreeWalker<RootNodeT: Document>(
1736 + root: RootNodeT,
1737 + whatToShow: 773,
1738 + filter?: NodeFilterInterface,
1739 + entityReferenceExpansion?: boolean
1740 + ): TreeWalker<RootNodeT, DocumentType | Document | Element | Text>;
1741 + createTreeWalker<RootNodeT: Document>(
1742 + root: RootNodeT,
1743 + whatToShow: 896,
1744 + filter?: NodeFilterInterface,
1745 + entityReferenceExpansion?: boolean
1746 + ): TreeWalker<RootNodeT, DocumentType | Document | Comment>;
1747 + createTreeWalker<RootNodeT: Document>(
1748 + root: RootNodeT,
1749 + whatToShow: 897,
1750 + filter?: NodeFilterInterface,
1751 + entityReferenceExpansion?: boolean
1752 + ): TreeWalker<RootNodeT, DocumentType | Document | Element | Comment>;
1753 + createTreeWalker<RootNodeT: Document>(
1754 + root: RootNodeT,
1755 + whatToShow: 900,
1756 + filter?: NodeFilterInterface,
1757 + entityReferenceExpansion?: boolean
1758 + ): TreeWalker<RootNodeT, DocumentType | Document | Text | Comment>;
1759 + createTreeWalker<RootNodeT: Document>(
1760 + root: RootNodeT,
1761 + whatToShow: 901,
1762 + filter?: NodeFilterInterface,
1763 + entityReferenceExpansion?: boolean
1764 + ): TreeWalker<RootNodeT, DocumentType | Document | Element | Text | Comment>;
1765 +
1766 + // When (whatToShow & NodeFilter.SHOW_DOCUMENT_FRAGMENT === 1), RootNodeT
1767 + // must be a DocumentFragment.
1768 + createNodeIterator<RootNodeT: DocumentFragment>(
1769 + root: RootNodeT,
1770 + whatToShow: 1024,
1771 + filter?: NodeFilterInterface
1772 + ): NodeIterator<RootNodeT, DocumentFragment>;
1773 + createNodeIterator<RootNodeT: DocumentFragment>(
1774 + root: RootNodeT,
1775 + whatToShow: 1025,
1776 + filter?: NodeFilterInterface
1777 + ): NodeIterator<RootNodeT, DocumentFragment | Element>;
1778 + createNodeIterator<RootNodeT: DocumentFragment>(
1779 + root: RootNodeT,
1780 + whatToShow: 1028,
1781 + filter?: NodeFilterInterface
1782 + ): NodeIterator<RootNodeT, DocumentFragment | Text>;
1783 + createNodeIterator<RootNodeT: DocumentFragment>(
1784 + root: RootNodeT,
1785 + whatToShow: 1029,
1786 + filter?: NodeFilterInterface
1787 + ): NodeIterator<RootNodeT, DocumentFragment | Element | Text>;
1788 + createNodeIterator<RootNodeT: DocumentFragment>(
1789 + root: RootNodeT,
1790 + whatToShow: 1152,
1791 + filter?: NodeFilterInterface
1792 + ): NodeIterator<RootNodeT, DocumentFragment | Comment>;
1793 + createNodeIterator<RootNodeT: DocumentFragment>(
1794 + root: RootNodeT,
1795 + whatToShow: 1153,
1796 + filter?: NodeFilterInterface
1797 + ): NodeIterator<RootNodeT, DocumentFragment | Element | Comment>;
1798 + createNodeIterator<RootNodeT: DocumentFragment>(
1799 + root: RootNodeT,
1800 + whatToShow: 1156,
1801 + filter?: NodeFilterInterface
1802 + ): NodeIterator<RootNodeT, DocumentFragment | Text | Comment>;
1803 + createNodeIterator<RootNodeT: DocumentFragment>(
1804 + root: RootNodeT,
1805 + whatToShow: 1157,
1806 + filter?: NodeFilterInterface
1807 + ): NodeIterator<RootNodeT, DocumentFragment | Element | Text | Comment>;
1808 + createTreeWalker<RootNodeT: DocumentFragment>(
1809 + root: RootNodeT,
1810 + whatToShow: 1024,
1811 + filter?: NodeFilterInterface,
1812 + entityReferenceExpansion?: boolean
1813 + ): TreeWalker<RootNodeT, DocumentFragment>;
1814 + createTreeWalker<RootNodeT: DocumentFragment>(
1815 + root: RootNodeT,
1816 + whatToShow: 1025,
1817 + filter?: NodeFilterInterface,
1818 + entityReferenceExpansion?: boolean
1819 + ): TreeWalker<RootNodeT, DocumentFragment | Element>;
1820 + createTreeWalker<RootNodeT: DocumentFragment>(
1821 + root: RootNodeT,
1822 + whatToShow: 1028,
1823 + filter?: NodeFilterInterface,
1824 + entityReferenceExpansion?: boolean
1825 + ): TreeWalker<RootNodeT, DocumentFragment | Text>;
1826 + createTreeWalker<RootNodeT: DocumentFragment>(
1827 + root: RootNodeT,
1828 + whatToShow: 1029,
1829 + filter?: NodeFilterInterface,
1830 + entityReferenceExpansion?: boolean
1831 + ): TreeWalker<RootNodeT, DocumentFragment | Element | Text>;
1832 + createTreeWalker<RootNodeT: DocumentFragment>(
1833 + root: RootNodeT,
1834 + whatToShow: 1152,
1835 + filter?: NodeFilterInterface,
1836 + entityReferenceExpansion?: boolean
1837 + ): TreeWalker<RootNodeT, DocumentFragment | Comment>;
1838 + createTreeWalker<RootNodeT: DocumentFragment>(
1839 + root: RootNodeT,
1840 + whatToShow: 1153,
1841 + filter?: NodeFilterInterface,
1842 + entityReferenceExpansion?: boolean
1843 + ): TreeWalker<RootNodeT, DocumentFragment | Element | Comment>;
1844 + createTreeWalker<RootNodeT: DocumentFragment>(
1845 + root: RootNodeT,
1846 + whatToShow: 1156,
1847 + filter?: NodeFilterInterface,
1848 + entityReferenceExpansion?: boolean
1849 + ): TreeWalker<RootNodeT, DocumentFragment | Text | Comment>;
1850 + createTreeWalker<RootNodeT: DocumentFragment>(
1851 + root: RootNodeT,
1852 + whatToShow: 1157,
1853 + filter?: NodeFilterInterface,
1854 + entityReferenceExpansion?: boolean
1855 + ): TreeWalker<RootNodeT, DocumentFragment | Element | Text | Comment>;
1856 +
1857 + // In the general case, RootNodeT may be any Node and whatToShow may be
1858 + // NodeFilter.SHOW_ALL or any combination of NodeFilter.SHOW_ELEMENT,
1859 + // NodeFilter.SHOW_TEXT and/or NodeFilter.SHOW_COMMENT
1860 + createNodeIterator<RootNodeT: Node>(
1861 + root: RootNodeT,
1862 + whatToShow: 1,
1863 + filter?: NodeFilterInterface
1864 + ): NodeIterator<RootNodeT, Element>;
1865 + createNodeIterator<RootNodeT: Node>(
1866 + root: RootNodeT,
1867 + whatToShow: 4,
1868 + filter?: NodeFilterInterface
1869 + ): NodeIterator<RootNodeT, Text>;
1870 + createNodeIterator<RootNodeT: Node>(
1871 + root: RootNodeT,
1872 + whatToShow: 5,
1873 + filter?: NodeFilterInterface
1874 + ): NodeIterator<RootNodeT, Element | Text>;
1875 + createNodeIterator<RootNodeT: Node>(
1876 + root: RootNodeT,
1877 + whatToShow: 128,
1878 + filter?: NodeFilterInterface
1879 + ): NodeIterator<RootNodeT, Comment>;
1880 + createNodeIterator<RootNodeT: Node>(
1881 + root: RootNodeT,
1882 + whatToShow: 129,
1883 + filter?: NodeFilterInterface
1884 + ): NodeIterator<RootNodeT, Element | Comment>;
1885 + createNodeIterator<RootNodeT: Node>(
1886 + root: RootNodeT,
1887 + whatToShow: 132,
1888 + filter?: NodeFilterInterface
1889 + ): NodeIterator<RootNodeT, Text | Comment>;
1890 + createNodeIterator<RootNodeT: Node>(
1891 + root: RootNodeT,
1892 + whatToShow: 133,
1893 + filter?: NodeFilterInterface
1894 + ): NodeIterator<RootNodeT, Text | Element | Comment>;
1895 + createTreeWalker<RootNodeT: Node>(
1896 + root: RootNodeT,
1897 + whatToShow: 1,
1898 + filter?: NodeFilterInterface,
1899 + entityReferenceExpansion?: boolean
1900 + ): TreeWalker<RootNodeT, Element>;
1901 + createTreeWalker<RootNodeT: Node>(
1902 + root: RootNodeT,
1903 + whatToShow: 4,
1904 + filter?: NodeFilterInterface,
1905 + entityReferenceExpansion?: boolean
1906 + ): TreeWalker<RootNodeT, Text>;
1907 + createTreeWalker<RootNodeT: Node>(
1908 + root: RootNodeT,
1909 + whatToShow: 5,
1910 + filter?: NodeFilterInterface,
1911 + entityReferenceExpansion?: boolean
1912 + ): TreeWalker<RootNodeT, Element | Text>;
1913 + createTreeWalker<RootNodeT: Node>(
1914 + root: RootNodeT,
1915 + whatToShow: 128,
1916 + filter?: NodeFilterInterface,
1917 + entityReferenceExpansion?: boolean
1918 + ): TreeWalker<RootNodeT, Comment>;
1919 + createTreeWalker<RootNodeT: Node>(
1920 + root: RootNodeT,
1921 + whatToShow: 129,
1922 + filter?: NodeFilterInterface,
1923 + entityReferenceExpansion?: boolean
1924 + ): TreeWalker<RootNodeT, Element | Comment>;
1925 + createTreeWalker<RootNodeT: Node>(
1926 + root: RootNodeT,
1927 + whatToShow: 132,
1928 + filter?: NodeFilterInterface,
1929 + entityReferenceExpansion?: boolean
1930 + ): TreeWalker<RootNodeT, Text | Comment>;
1931 + createTreeWalker<RootNodeT: Node>(
1932 + root: RootNodeT,
1933 + whatToShow: 133,
1934 + filter?: NodeFilterInterface,
1935 + entityReferenceExpansion?: boolean
1936 + ): TreeWalker<RootNodeT, Text | Element | Comment>;
1937 +
1938 + // Catch all for when we don't know the value of `whatToShow`
1939 + // And for when whatToShow is not provided, it is assumed to be SHOW_ALL
1940 + createNodeIterator<RootNodeT: Node>(
1941 + root: RootNodeT,
1942 + whatToShow?: number,
1943 + filter?: NodeFilterInterface
1944 + ): NodeIterator<RootNodeT, Node>;
1945 + createTreeWalker<RootNodeT: Node>(
1946 + root: RootNodeT,
1947 + whatToShow?: number,
1948 + filter?: NodeFilterInterface,
1949 + entityReferenceExpansion?: boolean
1950 + ): TreeWalker<RootNodeT, Node>;
1951 +
1952 + // From NonElementParentNode Mixin.
1953 + getElementById(elementId: string): HTMLElement | null;
1954 +
1955 + // From DocumentOrShadowRoot Mixin.
1956 + +styleSheets: StyleSheetList;
1957 + adoptedStyleSheets: Array<CSSStyleSheet>;
1958 +}
1959 +
1960 +declare class DocumentFragment extends Node {
1961 + // from ParentNode interface
1962 + childElementCount: number;
1963 + children: HTMLCollection<HTMLElement>;
1964 + firstElementChild: ?Element;
1965 + lastElementChild: ?Element;
1966 + append(...nodes: Array<string | Node>): void;
1967 + prepend(...nodes: Array<string | Node>): void;
1968 +
1969 + querySelector(selector: string): HTMLElement | null;
1970 + querySelectorAll(selector: string): NodeList<HTMLElement>;
1971 +
1972 + // From NonElementParentNode Mixin.
1973 + getElementById(elementId: string): HTMLElement | null;
1974 +}
1975 +
1976 +declare class Selection {
1977 + anchorNode: Node | null;
1978 + anchorOffset: number;
1979 + focusNode: Node | null;
1980 + focusOffset: number;
1981 + isCollapsed: boolean;
1982 + rangeCount: number;
1983 + type: string;
1984 + addRange(range: Range): void;
1985 + getRangeAt(index: number): Range;
1986 + removeRange(range: Range): void;
1987 + removeAllRanges(): void;
1988 + collapse(parentNode: Node | null, offset?: number): void;
1989 + collapseToStart(): void;
1990 + collapseToEnd(): void;
1991 + containsNode(aNode: Node, aPartlyContained?: boolean): boolean;
1992 + deleteFromDocument(): void;
1993 + extend(parentNode: Node, offset?: number): void;
1994 + empty(): void;
1995 + selectAllChildren(parentNode: Node): void;
1996 + setPosition(aNode: Node | null, offset?: number): void;
1997 + setBaseAndExtent(
1998 + anchorNode: Node,
1999 + anchorOffset: number,
2000 + focusNode: Node,
2001 + focusOffset: number
2002 + ): void;
2003 + toString(): string;
2004 +}
2005 +
2006 +declare class Range {
2007 + // extension
2008 + startOffset: number;
2009 + collapsed: boolean;
2010 + endOffset: number;
2011 + startContainer: Node;
2012 + endContainer: Node;
2013 + commonAncestorContainer: Node;
2014 + setStart(refNode: Node, offset: number): void;
2015 + setEndBefore(refNode: Node): void;
2016 + setStartBefore(refNode: Node): void;
2017 + selectNode(refNode: Node): void;
2018 + detach(): void;
2019 + getBoundingClientRect(): DOMRect;
2020 + toString(): string;
2021 + compareBoundaryPoints(how: number, sourceRange: Range): number;
2022 + insertNode(newNode: Node): void;
2023 + collapse(toStart: boolean): void;
2024 + selectNodeContents(refNode: Node): void;
2025 + cloneContents(): DocumentFragment;
2026 + setEnd(refNode: Node, offset: number): void;
2027 + cloneRange(): Range;
2028 + getClientRects(): DOMRectList;
2029 + surroundContents(newParent: Node): void;
2030 + deleteContents(): void;
2031 + setStartAfter(refNode: Node): void;
2032 + extractContents(): DocumentFragment;
2033 + setEndAfter(refNode: Node): void;
2034 + createContextualFragment(fragment: string | TrustedHTML): DocumentFragment;
2035 + intersectsNode(refNode: Node): boolean;
2036 + isPointInRange(refNode: Node, offset: number): boolean;
2037 + static END_TO_END: number;
2038 + static START_TO_START: number;
2039 + static START_TO_END: number;
2040 + static END_TO_START: number;
2041 +}
2042 +
2043 +declare var document: Document;
2044 +
2045 +declare class DOMTokenList {
2046 + @@iterator(): Iterator<string>;
2047 + length: number;
2048 + item(index: number): string;
2049 + contains(token: string): boolean;
2050 + add(...token: Array<string>): void;
2051 + remove(...token: Array<string>): void;
2052 + toggle(token: string, force?: boolean): boolean;
2053 + replace(oldToken: string, newToken: string): boolean;
2054 +
2055 + forEach(
2056 + callbackfn: (value: string, index: number, list: DOMTokenList) => any,
2057 + thisArg?: any
2058 + ): void;
2059 + entries(): Iterator<[number, string]>;
2060 + keys(): Iterator<number>;
2061 + values(): Iterator<string>;
2062 + [index: number]: string;
2063 +}
2064 +
2065 +declare class Element extends Node mixins mixin$Animatable {
2066 + assignedSlot: ?HTMLSlotElement;
2067 + attachShadow(shadowRootInitDict: ShadowRootInit): ShadowRoot;
2068 + attributes: NamedNodeMap;
2069 + classList: DOMTokenList;
2070 + className: string;
2071 + clientHeight: number;
2072 + clientLeft: number;
2073 + clientTop: number;
2074 + clientWidth: number;
2075 + id: string;
2076 + // flowlint unsafe-getters-setters:off
2077 + get innerHTML(): string;
2078 + set innerHTML(value: string | TrustedHTML): void;
2079 + // flowlint unsafe-getters-setters:error
2080 + localName: string;
2081 + namespaceURI: ?string;
2082 + nextElementSibling: ?Element;
2083 + // flowlint unsafe-getters-setters:off
2084 + get outerHTML(): string;
2085 + set outerHTML(value: string | TrustedHTML): void;
2086 + // flowlint unsafe-getters-setters:error
2087 + prefix: string | null;
2088 + previousElementSibling: ?Element;
2089 + scrollHeight: number;
2090 + scrollLeft: number;
2091 + scrollTop: number;
2092 + scrollWidth: number;
2093 + +tagName: string;
2094 +
2095 + // TODO: a lot more ARIA properties
2096 + ariaHidden: void | 'true' | 'false';
2097 +
2098 + closest(selectors: string): ?Element;
2099 +
2100 + getAttribute(name?: string): ?string;
2101 + getAttributeNames(): Array<string>;
2102 + getAttributeNS(namespaceURI: string | null, localName: string): string | null;
2103 + getAttributeNode(name: string): Attr | null;
2104 + getAttributeNodeNS(
2105 + namespaceURI: string | null,
2106 + localName: string
2107 + ): Attr | null;
2108 + getBoundingClientRect(): DOMRect;
2109 + getClientRects(): DOMRectList;
2110 + getElementsByClassName(names: string): HTMLCollection<HTMLElement>;
2111 + getElementsByTagName<TName: $Keys<HTMLElementTagNameMap>>(
2112 + qualifiedName: TName
2113 + ): HTMLCollection<HTMLElementTagNameMap[TName]>;
2114 + getElementsByTagNameNS<TName: $Keys<HTMLElementTagNameMap>>(
2115 + namespaceURI: 'http://www.w3.org/1999/xhtml',
2116 + qualifiedName: TName
2117 + ): HTMLCollection<HTMLElementTagNameMap[TName]>;
2118 + getElementsByTagNameNS(
2119 + namespaceURI: string | null,
2120 + qualifiedName: string
2121 + ): HTMLCollection<Element>;
2122 +
2123 + hasAttribute(name: string): boolean;
2124 + hasAttributeNS(namespaceURI: string | null, localName: string): boolean;
2125 + hasAttributes(): boolean;
2126 + hasPointerCapture(pointerId: number): boolean;
2127 + insertAdjacentElement(
2128 + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend',
2129 + element: Element
2130 + ): void;
2131 + insertAdjacentHTML(
2132 + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend',
2133 + html: string | TrustedHTML
2134 + ): void;
2135 + insertAdjacentText(
2136 + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend',
2137 + text: string
2138 + ): void;
2139 + matches(selector: string): boolean;
2140 + releasePointerCapture(pointerId: number): void;
2141 + removeAttribute(name?: string): void;
2142 + removeAttributeNode(attributeNode: Attr): Attr;
2143 + removeAttributeNS(namespaceURI: string | null, localName: string): void;
2144 + requestFullscreen(options?: {
2145 + navigationUI: 'auto' | 'show' | 'hide',
2146 + ...
2147 + }): Promise<void>;
2148 + requestPointerLock(): void;
2149 + scrollIntoView(
2150 + arg?:
2151 + | boolean
2152 + | {
2153 + behavior?: 'auto' | 'instant' | 'smooth',
2154 + block?: 'start' | 'center' | 'end' | 'nearest',
2155 + inline?: 'start' | 'center' | 'end' | 'nearest',
2156 + ...
2157 + }
2158 + ): void;
2159 + scroll(x: number, y: number): void;
2160 + scroll(options: ScrollToOptions): void;
2161 + scrollTo(x: number, y: number): void;
2162 + scrollTo(options: ScrollToOptions): void;
2163 + scrollBy(x: number, y: number): void;
2164 + scrollBy(options: ScrollToOptions): void;
2165 + setAttribute(name?: string, value?: string): void;
2166 + toggleAttribute(name?: string, force?: boolean): void;
2167 + setAttributeNS(
2168 + namespaceURI: string | null,
2169 + qualifiedName: string,
2170 + value: string
2171 + ): void;
2172 + setAttributeNode(newAttr: Attr): Attr | null;
2173 + setAttributeNodeNS(newAttr: Attr): Attr | null;
2174 + setPointerCapture(pointerId: number): void;
2175 + shadowRoot?: ShadowRoot;
2176 + slot?: string;
2177 +
2178 + // from ParentNode interface
2179 + childElementCount: number;
2180 + children: HTMLCollection<HTMLElement>;
2181 + firstElementChild: ?Element;
2182 + lastElementChild: ?Element;
2183 + append(...nodes: Array<string | Node>): void;
2184 + prepend(...nodes: Array<string | Node>): void;
2185 +
2186 + querySelector<TSelector: $Keys<HTMLElementTagNameMap>>(
2187 + selector: TSelector
2188 + ): HTMLElementTagNameMap[TSelector] | null;
2189 + querySelectorAll<TSelector: $Keys<HTMLElementTagNameMap>>(
2190 + selector: TSelector
2191 + ): NodeList<HTMLElementTagNameMap[TSelector]>;
2192 +
2193 + // from ChildNode interface
2194 + after(...nodes: Array<string | Node>): void;
2195 + before(...nodes: Array<string | Node>): void;
2196 + replaceWith(...nodes: Array<string | Node>): void;
2197 + remove(): void;
2198 +}
2199 +
2200 +declare class HitRegionOptions {
2201 + path?: Path2D;
2202 + fillRule?: CanvasFillRule;
2203 + id?: string;
2204 + parentID?: string;
2205 + cursor?: string;
2206 + control?: Element;
2207 + label: ?string;
2208 + role: ?string;
2209 +}
2210 +
2211 +declare class SVGMatrix {
2212 + getComponent(index: number): number;
2213 + mMultiply(secondMatrix: SVGMatrix): SVGMatrix;
2214 + inverse(): SVGMatrix;
2215 + mTranslate(x: number, y: number): SVGMatrix;
2216 + mScale(scaleFactor: number): SVGMatrix;
2217 + mRotate(angle: number): SVGMatrix;
2218 +}
2219 +
2220 +// WebGL idl: https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
2221 +
2222 +type WebGLContextAttributes = {
2223 + alpha: boolean,
2224 + depth: boolean,
2225 + stencil: boolean,
2226 + antialias: boolean,
2227 + premultipliedAlpha: boolean,
2228 + preserveDrawingBuffer: boolean,
2229 + preferLowPowerToHighPerformance: boolean,
2230 + failIfMajorPerformanceCaveat: boolean,
2231 + ...
2232 +};
2233 +
2234 +interface WebGLObject {}
2235 +
2236 +interface WebGLBuffer extends WebGLObject {}
2237 +
2238 +interface WebGLFramebuffer extends WebGLObject {}
2239 +
2240 +interface WebGLProgram extends WebGLObject {}
2241 +
2242 +interface WebGLRenderbuffer extends WebGLObject {}
2243 +
2244 +interface WebGLShader extends WebGLObject {}
2245 +
2246 +interface WebGLTexture extends WebGLObject {}
2247 +
2248 +interface WebGLUniformLocation {}
2249 +
2250 +interface WebGLActiveInfo {
2251 + size: number;
2252 + type: number;
2253 + name: string;
2254 +}
2255 +
2256 +interface WebGLShaderPrecisionFormat {
2257 + rangeMin: number;
2258 + rangeMax: number;
2259 + precision: number;
2260 +}
2261 +
2262 +type BufferDataSource = ArrayBuffer | $ArrayBufferView;
2263 +
2264 +type TexImageSource =
2265 + | ImageBitmap
2266 + | ImageData
2267 + | HTMLImageElement
2268 + | HTMLCanvasElement
2269 + | HTMLVideoElement;
2270 +
2271 +type VertexAttribFVSource = Float32Array | Array<number>;
2272 +
2273 +/* flow */
2274 +declare class WebGLRenderingContext {
2275 + static DEPTH_BUFFER_BIT: 0x00000100;
2276 + DEPTH_BUFFER_BIT: 0x00000100;
2277 + static STENCIL_BUFFER_BIT: 0x00000400;
2278 + STENCIL_BUFFER_BIT: 0x00000400;
2279 + static COLOR_BUFFER_BIT: 0x00004000;
2280 + COLOR_BUFFER_BIT: 0x00004000;
2281 + static POINTS: 0x0000;
2282 + POINTS: 0x0000;
2283 + static LINES: 0x0001;
2284 + LINES: 0x0001;
2285 + static LINE_LOOP: 0x0002;
2286 + LINE_LOOP: 0x0002;
2287 + static LINE_STRIP: 0x0003;
2288 + LINE_STRIP: 0x0003;
2289 + static TRIANGLES: 0x0004;
2290 + TRIANGLES: 0x0004;
2291 + static TRIANGLE_STRIP: 0x0005;
2292 + TRIANGLE_STRIP: 0x0005;
2293 + static TRIANGLE_FAN: 0x0006;
2294 + TRIANGLE_FAN: 0x0006;
2295 + static ZERO: 0;
2296 + ZERO: 0;
2297 + static ONE: 1;
2298 + ONE: 1;
2299 + static SRC_COLOR: 0x0300;
2300 + SRC_COLOR: 0x0300;
2301 + static ONE_MINUS_SRC_COLOR: 0x0301;
2302 + ONE_MINUS_SRC_COLOR: 0x0301;
2303 + static SRC_ALPHA: 0x0302;
2304 + SRC_ALPHA: 0x0302;
2305 + static ONE_MINUS_SRC_ALPHA: 0x0303;
2306 + ONE_MINUS_SRC_ALPHA: 0x0303;
2307 + static DST_ALPHA: 0x0304;
2308 + DST_ALPHA: 0x0304;
2309 + static ONE_MINUS_DST_ALPHA: 0x0305;
2310 + ONE_MINUS_DST_ALPHA: 0x0305;
2311 + static DST_COLOR: 0x0306;
2312 + DST_COLOR: 0x0306;
2313 + static ONE_MINUS_DST_COLOR: 0x0307;
2314 + ONE_MINUS_DST_COLOR: 0x0307;
2315 + static SRC_ALPHA_SATURATE: 0x0308;
2316 + SRC_ALPHA_SATURATE: 0x0308;
2317 + static FUNC_ADD: 0x8006;
2318 + FUNC_ADD: 0x8006;
2319 + static BLEND_EQUATION: 0x8009;
2320 + BLEND_EQUATION: 0x8009;
2321 + static BLEND_EQUATION_RGB: 0x8009;
2322 + BLEND_EQUATION_RGB: 0x8009;
2323 + static BLEND_EQUATION_ALPHA: 0x883d;
2324 + BLEND_EQUATION_ALPHA: 0x883d;
2325 + static FUNC_SUBTRACT: 0x800a;
2326 + FUNC_SUBTRACT: 0x800a;
2327 + static FUNC_REVERSE_SUBTRACT: 0x800b;
2328 + FUNC_REVERSE_SUBTRACT: 0x800b;
2329 + static BLEND_DST_RGB: 0x80c8;
2330 + BLEND_DST_RGB: 0x80c8;
2331 + static BLEND_SRC_RGB: 0x80c9;
2332 + BLEND_SRC_RGB: 0x80c9;
2333 + static BLEND_DST_ALPHA: 0x80ca;
2334 + BLEND_DST_ALPHA: 0x80ca;
2335 + static BLEND_SRC_ALPHA: 0x80cb;
2336 + BLEND_SRC_ALPHA: 0x80cb;
2337 + static CONSTANT_COLOR: 0x8001;
2338 + CONSTANT_COLOR: 0x8001;
2339 + static ONE_MINUS_CONSTANT_COLOR: 0x8002;
2340 + ONE_MINUS_CONSTANT_COLOR: 0x8002;
2341 + static CONSTANT_ALPHA: 0x8003;
2342 + CONSTANT_ALPHA: 0x8003;
2343 + static ONE_MINUS_CONSTANT_ALPHA: 0x8004;
2344 + ONE_MINUS_CONSTANT_ALPHA: 0x8004;
2345 + static BLEND_COLOR: 0x8005;
2346 + BLEND_COLOR: 0x8005;
2347 + static ARRAY_BUFFER: 0x8892;
2348 + ARRAY_BUFFER: 0x8892;
2349 + static ELEMENT_ARRAY_BUFFER: 0x8893;
2350 + ELEMENT_ARRAY_BUFFER: 0x8893;
2351 + static ARRAY_BUFFER_BINDING: 0x8894;
2352 + ARRAY_BUFFER_BINDING: 0x8894;
2353 + static ELEMENT_ARRAY_BUFFER_BINDING: 0x8895;
2354 + ELEMENT_ARRAY_BUFFER_BINDING: 0x8895;
2355 + static STREAM_DRAW: 0x88e0;
2356 + STREAM_DRAW: 0x88e0;
2357 + static STATIC_DRAW: 0x88e4;
2358 + STATIC_DRAW: 0x88e4;
2359 + static DYNAMIC_DRAW: 0x88e8;
2360 + DYNAMIC_DRAW: 0x88e8;
2361 + static BUFFER_SIZE: 0x8764;
2362 + BUFFER_SIZE: 0x8764;
2363 + static BUFFER_USAGE: 0x8765;
2364 + BUFFER_USAGE: 0x8765;
2365 + static CURRENT_VERTEX_ATTRIB: 0x8626;
2366 + CURRENT_VERTEX_ATTRIB: 0x8626;
2367 + static FRONT: 0x0404;
2368 + FRONT: 0x0404;
2369 + static BACK: 0x0405;
2370 + BACK: 0x0405;
2371 + static FRONT_AND_BACK: 0x0408;
2372 + FRONT_AND_BACK: 0x0408;
2373 + static CULL_FACE: 0x0b44;
2374 + CULL_FACE: 0x0b44;
2375 + static BLEND: 0x0be2;
2376 + BLEND: 0x0be2;
2377 + static DITHER: 0x0bd0;
2378 + DITHER: 0x0bd0;
2379 + static STENCIL_TEST: 0x0b90;
2380 + STENCIL_TEST: 0x0b90;
2381 + static DEPTH_TEST: 0x0b71;
2382 + DEPTH_TEST: 0x0b71;
2383 + static SCISSOR_TEST: 0x0c11;
2384 + SCISSOR_TEST: 0x0c11;
2385 + static POLYGON_OFFSET_FILL: 0x8037;
2386 + POLYGON_OFFSET_FILL: 0x8037;
2387 + static SAMPLE_ALPHA_TO_COVERAGE: 0x809e;
2388 + SAMPLE_ALPHA_TO_COVERAGE: 0x809e;
2389 + static SAMPLE_COVERAGE: 0x80a0;
2390 + SAMPLE_COVERAGE: 0x80a0;
2391 + static NO_ERROR: 0;
2392 + NO_ERROR: 0;
2393 + static INVALID_ENUM: 0x0500;
2394 + INVALID_ENUM: 0x0500;
2395 + static INVALID_VALUE: 0x0501;
2396 + INVALID_VALUE: 0x0501;
2397 + static INVALID_OPERATION: 0x0502;
2398 + INVALID_OPERATION: 0x0502;
2399 + static OUT_OF_MEMORY: 0x0505;
2400 + OUT_OF_MEMORY: 0x0505;
2401 + static CW: 0x0900;
2402 + CW: 0x0900;
2403 + static CCW: 0x0901;
2404 + CCW: 0x0901;
2405 + static LINE_WIDTH: 0x0b21;
2406 + LINE_WIDTH: 0x0b21;
2407 + static ALIASED_POINT_SIZE_RANGE: 0x846d;
2408 + ALIASED_POINT_SIZE_RANGE: 0x846d;
2409 + static ALIASED_LINE_WIDTH_RANGE: 0x846e;
2410 + ALIASED_LINE_WIDTH_RANGE: 0x846e;
2411 + static CULL_FACE_MODE: 0x0b45;
2412 + CULL_FACE_MODE: 0x0b45;
2413 + static FRONT_FACE: 0x0b46;
2414 + FRONT_FACE: 0x0b46;
2415 + static DEPTH_RANGE: 0x0b70;
2416 + DEPTH_RANGE: 0x0b70;
2417 + static DEPTH_WRITEMASK: 0x0b72;
2418 + DEPTH_WRITEMASK: 0x0b72;
2419 + static DEPTH_CLEAR_VALUE: 0x0b73;
2420 + DEPTH_CLEAR_VALUE: 0x0b73;
2421 + static DEPTH_FUNC: 0x0b74;
2422 + DEPTH_FUNC: 0x0b74;
2423 + static STENCIL_CLEAR_VALUE: 0x0b91;
2424 + STENCIL_CLEAR_VALUE: 0x0b91;
2425 + static STENCIL_FUNC: 0x0b92;
2426 + STENCIL_FUNC: 0x0b92;
2427 + static STENCIL_FAIL: 0x0b94;
2428 + STENCIL_FAIL: 0x0b94;
2429 + static STENCIL_PASS_DEPTH_FAIL: 0x0b95;
2430 + STENCIL_PASS_DEPTH_FAIL: 0x0b95;
2431 + static STENCIL_PASS_DEPTH_PASS: 0x0b96;
2432 + STENCIL_PASS_DEPTH_PASS: 0x0b96;
2433 + static STENCIL_REF: 0x0b97;
2434 + STENCIL_REF: 0x0b97;
2435 + static STENCIL_VALUE_MASK: 0x0b93;
2436 + STENCIL_VALUE_MASK: 0x0b93;
2437 + static STENCIL_WRITEMASK: 0x0b98;
2438 + STENCIL_WRITEMASK: 0x0b98;
2439 + static STENCIL_BACK_FUNC: 0x8800;
2440 + STENCIL_BACK_FUNC: 0x8800;
2441 + static STENCIL_BACK_FAIL: 0x8801;
2442 + STENCIL_BACK_FAIL: 0x8801;
2443 + static STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802;
2444 + STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802;
2445 + static STENCIL_BACK_PASS_DEPTH_PASS: 0x8803;
2446 + STENCIL_BACK_PASS_DEPTH_PASS: 0x8803;
2447 + static STENCIL_BACK_REF: 0x8ca3;
2448 + STENCIL_BACK_REF: 0x8ca3;
2449 + static STENCIL_BACK_VALUE_MASK: 0x8ca4;
2450 + STENCIL_BACK_VALUE_MASK: 0x8ca4;
2451 + static STENCIL_BACK_WRITEMASK: 0x8ca5;
2452 + STENCIL_BACK_WRITEMASK: 0x8ca5;
2453 + static VIEWPORT: 0x0ba2;
2454 + VIEWPORT: 0x0ba2;
2455 + static SCISSOR_BOX: 0x0c10;
2456 + SCISSOR_BOX: 0x0c10;
2457 + static COLOR_CLEAR_VALUE: 0x0c22;
2458 + COLOR_CLEAR_VALUE: 0x0c22;
2459 + static COLOR_WRITEMASK: 0x0c23;
2460 + COLOR_WRITEMASK: 0x0c23;
2461 + static UNPACK_ALIGNMENT: 0x0cf5;
2462 + UNPACK_ALIGNMENT: 0x0cf5;
2463 + static PACK_ALIGNMENT: 0x0d05;
2464 + PACK_ALIGNMENT: 0x0d05;
2465 + static MAX_TEXTURE_SIZE: 0x0d33;
2466 + MAX_TEXTURE_SIZE: 0x0d33;
2467 + static MAX_VIEWPORT_DIMS: 0x0d3a;
2468 + MAX_VIEWPORT_DIMS: 0x0d3a;
2469 + static SUBPIXEL_BITS: 0x0d50;
2470 + SUBPIXEL_BITS: 0x0d50;
2471 + static RED_BITS: 0x0d52;
2472 + RED_BITS: 0x0d52;
2473 + static GREEN_BITS: 0x0d53;
2474 + GREEN_BITS: 0x0d53;
2475 + static BLUE_BITS: 0x0d54;
2476 + BLUE_BITS: 0x0d54;
2477 + static ALPHA_BITS: 0x0d55;
2478 + ALPHA_BITS: 0x0d55;
2479 + static DEPTH_BITS: 0x0d56;
2480 + DEPTH_BITS: 0x0d56;
2481 + static STENCIL_BITS: 0x0d57;
2482 + STENCIL_BITS: 0x0d57;
2483 + static POLYGON_OFFSET_UNITS: 0x2a00;
2484 + POLYGON_OFFSET_UNITS: 0x2a00;
2485 + static POLYGON_OFFSET_FACTOR: 0x8038;
2486 + POLYGON_OFFSET_FACTOR: 0x8038;
2487 + static TEXTURE_BINDING_2D: 0x8069;
2488 + TEXTURE_BINDING_2D: 0x8069;
2489 + static SAMPLE_BUFFERS: 0x80a8;
2490 + SAMPLE_BUFFERS: 0x80a8;
2491 + static SAMPLES: 0x80a9;
2492 + SAMPLES: 0x80a9;
2493 + static SAMPLE_COVERAGE_VALUE: 0x80aa;
2494 + SAMPLE_COVERAGE_VALUE: 0x80aa;
2495 + static SAMPLE_COVERAGE_INVERT: 0x80ab;
2496 + SAMPLE_COVERAGE_INVERT: 0x80ab;
2497 + static COMPRESSED_TEXTURE_FORMATS: 0x86a3;
2498 + COMPRESSED_TEXTURE_FORMATS: 0x86a3;
2499 + static DONT_CARE: 0x1100;
2500 + DONT_CARE: 0x1100;
2501 + static FASTEST: 0x1101;
2502 + FASTEST: 0x1101;
2503 + static NICEST: 0x1102;
2504 + NICEST: 0x1102;
2505 + static GENERATE_MIPMAP_HINT: 0x8192;
2506 + GENERATE_MIPMAP_HINT: 0x8192;
2507 + static BYTE: 0x1400;
2508 + BYTE: 0x1400;
2509 + static UNSIGNED_BYTE: 0x1401;
2510 + UNSIGNED_BYTE: 0x1401;
2511 + static SHORT: 0x1402;
2512 + SHORT: 0x1402;
2513 + static UNSIGNED_SHORT: 0x1403;
2514 + UNSIGNED_SHORT: 0x1403;
2515 + static INT: 0x1404;
2516 + INT: 0x1404;
2517 + static UNSIGNED_INT: 0x1405;
2518 + UNSIGNED_INT: 0x1405;
2519 + static FLOAT: 0x1406;
2520 + FLOAT: 0x1406;
2521 + static DEPTH_COMPONENT: 0x1902;
2522 + DEPTH_COMPONENT: 0x1902;
2523 + static ALPHA: 0x1906;
2524 + ALPHA: 0x1906;
2525 + static RGB: 0x1907;
2526 + RGB: 0x1907;
2527 + static RGBA: 0x1908;
2528 + RGBA: 0x1908;
2529 + static LUMINANCE: 0x1909;
2530 + LUMINANCE: 0x1909;
2531 + static LUMINANCE_ALPHA: 0x190a;
2532 + LUMINANCE_ALPHA: 0x190a;
2533 + static UNSIGNED_SHORT_4_4_4_4: 0x8033;
2534 + UNSIGNED_SHORT_4_4_4_4: 0x8033;
2535 + static UNSIGNED_SHORT_5_5_5_1: 0x8034;
2536 + UNSIGNED_SHORT_5_5_5_1: 0x8034;
2537 + static UNSIGNED_SHORT_5_6_5: 0x8363;
2538 + UNSIGNED_SHORT_5_6_5: 0x8363;
2539 + static FRAGMENT_SHADER: 0x8b30;
2540 + FRAGMENT_SHADER: 0x8b30;
2541 + static VERTEX_SHADER: 0x8b31;
2542 + VERTEX_SHADER: 0x8b31;
2543 + static MAX_VERTEX_ATTRIBS: 0x8869;
2544 + MAX_VERTEX_ATTRIBS: 0x8869;
2545 + static MAX_VERTEX_UNIFORM_VECTORS: 0x8dfb;
2546 + MAX_VERTEX_UNIFORM_VECTORS: 0x8dfb;
2547 + static MAX_VARYING_VECTORS: 0x8dfc;
2548 + MAX_VARYING_VECTORS: 0x8dfc;
2549 + static MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8b4d;
2550 + MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8b4d;
2551 + static MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8b4c;
2552 + MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8b4c;
2553 + static MAX_TEXTURE_IMAGE_UNITS: 0x8872;
2554 + MAX_TEXTURE_IMAGE_UNITS: 0x8872;
2555 + static MAX_FRAGMENT_UNIFORM_VECTORS: 0x8dfd;
2556 + MAX_FRAGMENT_UNIFORM_VECTORS: 0x8dfd;
2557 + static SHADER_TYPE: 0x8b4f;
2558 + SHADER_TYPE: 0x8b4f;
2559 + static DELETE_STATUS: 0x8b80;
2560 + DELETE_STATUS: 0x8b80;
2561 + static LINK_STATUS: 0x8b82;
2562 + LINK_STATUS: 0x8b82;
2563 + static VALIDATE_STATUS: 0x8b83;
2564 + VALIDATE_STATUS: 0x8b83;
2565 + static ATTACHED_SHADERS: 0x8b85;
2566 + ATTACHED_SHADERS: 0x8b85;
2567 + static ACTIVE_UNIFORMS: 0x8b86;
2568 + ACTIVE_UNIFORMS: 0x8b86;
2569 + static ACTIVE_ATTRIBUTES: 0x8b89;
2570 + ACTIVE_ATTRIBUTES: 0x8b89;
2571 + static SHADING_LANGUAGE_VERSION: 0x8b8c;
2572 + SHADING_LANGUAGE_VERSION: 0x8b8c;
2573 + static CURRENT_PROGRAM: 0x8b8d;
2574 + CURRENT_PROGRAM: 0x8b8d;
2575 + static NEVER: 0x0200;
2576 + NEVER: 0x0200;
2577 + static LESS: 0x0201;
2578 + LESS: 0x0201;
2579 + static EQUAL: 0x0202;
2580 + EQUAL: 0x0202;
2581 + static LEQUAL: 0x0203;
2582 + LEQUAL: 0x0203;
2583 + static GREATER: 0x0204;
2584 + GREATER: 0x0204;
2585 + static NOTEQUAL: 0x0205;
2586 + NOTEQUAL: 0x0205;
2587 + static GEQUAL: 0x0206;
2588 + GEQUAL: 0x0206;
2589 + static ALWAYS: 0x0207;
2590 + ALWAYS: 0x0207;
2591 + static KEEP: 0x1e00;
2592 + KEEP: 0x1e00;
2593 + static REPLACE: 0x1e01;
2594 + REPLACE: 0x1e01;
2595 + static INCR: 0x1e02;
2596 + INCR: 0x1e02;
2597 + static DECR: 0x1e03;
2598 + DECR: 0x1e03;
2599 + static INVERT: 0x150a;
2600 + INVERT: 0x150a;
2601 + static INCR_WRAP: 0x8507;
2602 + INCR_WRAP: 0x8507;
2603 + static DECR_WRAP: 0x8508;
2604 + DECR_WRAP: 0x8508;
2605 + static VENDOR: 0x1f00;
2606 + VENDOR: 0x1f00;
2607 + static RENDERER: 0x1f01;
2608 + RENDERER: 0x1f01;
2609 + static VERSION: 0x1f02;
2610 + VERSION: 0x1f02;
2611 + static NEAREST: 0x2600;
2612 + NEAREST: 0x2600;
2613 + static LINEAR: 0x2601;
2614 + LINEAR: 0x2601;
2615 + static NEAREST_MIPMAP_NEAREST: 0x2700;
2616 + NEAREST_MIPMAP_NEAREST: 0x2700;
2617 + static LINEAR_MIPMAP_NEAREST: 0x2701;
2618 + LINEAR_MIPMAP_NEAREST: 0x2701;
2619 + static NEAREST_MIPMAP_LINEAR: 0x2702;
2620 + NEAREST_MIPMAP_LINEAR: 0x2702;
2621 + static LINEAR_MIPMAP_LINEAR: 0x2703;
2622 + LINEAR_MIPMAP_LINEAR: 0x2703;
2623 + static TEXTURE_MAG_FILTER: 0x2800;
2624 + TEXTURE_MAG_FILTER: 0x2800;
2625 + static TEXTURE_MIN_FILTER: 0x2801;
2626 + TEXTURE_MIN_FILTER: 0x2801;
2627 + static TEXTURE_WRAP_S: 0x2802;
2628 + TEXTURE_WRAP_S: 0x2802;
2629 + static TEXTURE_WRAP_T: 0x2803;
2630 + TEXTURE_WRAP_T: 0x2803;
2631 + static TEXTURE_2D: 0x0de1;
2632 + TEXTURE_2D: 0x0de1;
2633 + static TEXTURE: 0x1702;
2634 + TEXTURE: 0x1702;
2635 + static TEXTURE_CUBE_MAP: 0x8513;
2636 + TEXTURE_CUBE_MAP: 0x8513;
2637 + static TEXTURE_BINDING_CUBE_MAP: 0x8514;
2638 + TEXTURE_BINDING_CUBE_MAP: 0x8514;
2639 + static TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515;
2640 + TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515;
2641 + static TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516;
2642 + TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516;
2643 + static TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517;
2644 + TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517;
2645 + static TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518;
2646 + TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518;
2647 + static TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519;
2648 + TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519;
2649 + static TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851a;
2650 + TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851a;
2651 + static MAX_CUBE_MAP_TEXTURE_SIZE: 0x851c;
2652 + MAX_CUBE_MAP_TEXTURE_SIZE: 0x851c;
2653 + static TEXTURE0: 0x84c0;
2654 + TEXTURE0: 0x84c0;
2655 + static TEXTURE1: 0x84c1;
2656 + TEXTURE1: 0x84c1;
2657 + static TEXTURE2: 0x84c2;
2658 + TEXTURE2: 0x84c2;
2659 + static TEXTURE3: 0x84c3;
2660 + TEXTURE3: 0x84c3;
2661 + static TEXTURE4: 0x84c4;
2662 + TEXTURE4: 0x84c4;
2663 + static TEXTURE5: 0x84c5;
2664 + TEXTURE5: 0x84c5;
2665 + static TEXTURE6: 0x84c6;
2666 + TEXTURE6: 0x84c6;
2667 + static TEXTURE7: 0x84c7;
2668 + TEXTURE7: 0x84c7;
2669 + static TEXTURE8: 0x84c8;
2670 + TEXTURE8: 0x84c8;
2671 + static TEXTURE9: 0x84c9;
2672 + TEXTURE9: 0x84c9;
2673 + static TEXTURE10: 0x84ca;
2674 + TEXTURE10: 0x84ca;
2675 + static TEXTURE11: 0x84cb;
2676 + TEXTURE11: 0x84cb;
2677 + static TEXTURE12: 0x84cc;
2678 + TEXTURE12: 0x84cc;
2679 + static TEXTURE13: 0x84cd;
2680 + TEXTURE13: 0x84cd;
2681 + static TEXTURE14: 0x84ce;
2682 + TEXTURE14: 0x84ce;
2683 + static TEXTURE15: 0x84cf;
2684 + TEXTURE15: 0x84cf;
2685 + static TEXTURE16: 0x84d0;
2686 + TEXTURE16: 0x84d0;
2687 + static TEXTURE17: 0x84d1;
2688 + TEXTURE17: 0x84d1;
2689 + static TEXTURE18: 0x84d2;
2690 + TEXTURE18: 0x84d2;
2691 + static TEXTURE19: 0x84d3;
2692 + TEXTURE19: 0x84d3;
2693 + static TEXTURE20: 0x84d4;
2694 + TEXTURE20: 0x84d4;
2695 + static TEXTURE21: 0x84d5;
2696 + TEXTURE21: 0x84d5;
2697 + static TEXTURE22: 0x84d6;
2698 + TEXTURE22: 0x84d6;
2699 + static TEXTURE23: 0x84d7;
2700 + TEXTURE23: 0x84d7;
2701 + static TEXTURE24: 0x84d8;
2702 + TEXTURE24: 0x84d8;
2703 + static TEXTURE25: 0x84d9;
2704 + TEXTURE25: 0x84d9;
2705 + static TEXTURE26: 0x84da;
2706 + TEXTURE26: 0x84da;
2707 + static TEXTURE27: 0x84db;
2708 + TEXTURE27: 0x84db;
2709 + static TEXTURE28: 0x84dc;
2710 + TEXTURE28: 0x84dc;
2711 + static TEXTURE29: 0x84dd;
2712 + TEXTURE29: 0x84dd;
2713 + static TEXTURE30: 0x84de;
2714 + TEXTURE30: 0x84de;
2715 + static TEXTURE31: 0x84df;
2716 + TEXTURE31: 0x84df;
2717 + static ACTIVE_TEXTURE: 0x84e0;
2718 + ACTIVE_TEXTURE: 0x84e0;
2719 + static REPEAT: 0x2901;
2720 + REPEAT: 0x2901;
2721 + static CLAMP_TO_EDGE: 0x812f;
2722 + CLAMP_TO_EDGE: 0x812f;
2723 + static MIRRORED_REPEAT: 0x8370;
2724 + MIRRORED_REPEAT: 0x8370;
2725 + static FLOAT_VEC2: 0x8b50;
2726 + FLOAT_VEC2: 0x8b50;
2727 + static FLOAT_VEC3: 0x8b51;
2728 + FLOAT_VEC3: 0x8b51;
2729 + static FLOAT_VEC4: 0x8b52;
2730 + FLOAT_VEC4: 0x8b52;
2731 + static INT_VEC2: 0x8b53;
2732 + INT_VEC2: 0x8b53;
2733 + static INT_VEC3: 0x8b54;
2734 + INT_VEC3: 0x8b54;
2735 + static INT_VEC4: 0x8b55;
2736 + INT_VEC4: 0x8b55;
2737 + static BOOL: 0x8b56;
2738 + BOOL: 0x8b56;
2739 + static BOOL_VEC2: 0x8b57;
2740 + BOOL_VEC2: 0x8b57;
2741 + static BOOL_VEC3: 0x8b58;
2742 + BOOL_VEC3: 0x8b58;
2743 + static BOOL_VEC4: 0x8b59;
2744 + BOOL_VEC4: 0x8b59;
2745 + static FLOAT_MAT2: 0x8b5a;
2746 + FLOAT_MAT2: 0x8b5a;
2747 + static FLOAT_MAT3: 0x8b5b;
2748 + FLOAT_MAT3: 0x8b5b;
2749 + static FLOAT_MAT4: 0x8b5c;
2750 + FLOAT_MAT4: 0x8b5c;
2751 + static SAMPLER_2D: 0x8b5e;
2752 + SAMPLER_2D: 0x8b5e;
2753 + static SAMPLER_CUBE: 0x8b60;
2754 + SAMPLER_CUBE: 0x8b60;
2755 + static VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622;
2756 + VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622;
2757 + static VERTEX_ATTRIB_ARRAY_SIZE: 0x8623;
2758 + VERTEX_ATTRIB_ARRAY_SIZE: 0x8623;
2759 + static VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624;
2760 + VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624;
2761 + static VERTEX_ATTRIB_ARRAY_TYPE: 0x8625;
2762 + VERTEX_ATTRIB_ARRAY_TYPE: 0x8625;
2763 + static VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886a;
2764 + VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886a;
2765 + static VERTEX_ATTRIB_ARRAY_POINTER: 0x8645;
2766 + VERTEX_ATTRIB_ARRAY_POINTER: 0x8645;
2767 + static VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889f;
2768 + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889f;
2769 + static IMPLEMENTATION_COLOR_READ_TYPE: 0x8b9a;
2770 + IMPLEMENTATION_COLOR_READ_TYPE: 0x8b9a;
2771 + static IMPLEMENTATION_COLOR_READ_FORMAT: 0x8b9b;
2772 + IMPLEMENTATION_COLOR_READ_FORMAT: 0x8b9b;
2773 + static COMPILE_STATUS: 0x8b81;
2774 + COMPILE_STATUS: 0x8b81;
2775 + static LOW_FLOAT: 0x8df0;
2776 + LOW_FLOAT: 0x8df0;
2777 + static MEDIUM_FLOAT: 0x8df1;
2778 + MEDIUM_FLOAT: 0x8df1;
2779 + static HIGH_FLOAT: 0x8df2;
2780 + HIGH_FLOAT: 0x8df2;
2781 + static LOW_INT: 0x8df3;
2782 + LOW_INT: 0x8df3;
2783 + static MEDIUM_INT: 0x8df4;
2784 + MEDIUM_INT: 0x8df4;
2785 + static HIGH_INT: 0x8df5;
2786 + HIGH_INT: 0x8df5;
2787 + static FRAMEBUFFER: 0x8d40;
2788 + FRAMEBUFFER: 0x8d40;
2789 + static RENDERBUFFER: 0x8d41;
2790 + RENDERBUFFER: 0x8d41;
2791 + static RGBA4: 0x8056;
2792 + RGBA4: 0x8056;
2793 + static RGB5_A1: 0x8057;
2794 + RGB5_A1: 0x8057;
2795 + static RGB565: 0x8d62;
2796 + RGB565: 0x8d62;
2797 + static DEPTH_COMPONENT16: 0x81a5;
2798 + DEPTH_COMPONENT16: 0x81a5;
2799 + static STENCIL_INDEX: 0x1901;
2800 + STENCIL_INDEX: 0x1901;
2801 + static STENCIL_INDEX8: 0x8d48;
2802 + STENCIL_INDEX8: 0x8d48;
2803 + static DEPTH_STENCIL: 0x84f9;
2804 + DEPTH_STENCIL: 0x84f9;
2805 + static RENDERBUFFER_WIDTH: 0x8d42;
2806 + RENDERBUFFER_WIDTH: 0x8d42;
2807 + static RENDERBUFFER_HEIGHT: 0x8d43;
2808 + RENDERBUFFER_HEIGHT: 0x8d43;
2809 + static RENDERBUFFER_INTERNAL_FORMAT: 0x8d44;
2810 + RENDERBUFFER_INTERNAL_FORMAT: 0x8d44;
2811 + static RENDERBUFFER_RED_SIZE: 0x8d50;
2812 + RENDERBUFFER_RED_SIZE: 0x8d50;
2813 + static RENDERBUFFER_GREEN_SIZE: 0x8d51;
2814 + RENDERBUFFER_GREEN_SIZE: 0x8d51;
2815 + static RENDERBUFFER_BLUE_SIZE: 0x8d52;
2816 + RENDERBUFFER_BLUE_SIZE: 0x8d52;
2817 + static RENDERBUFFER_ALPHA_SIZE: 0x8d53;
2818 + RENDERBUFFER_ALPHA_SIZE: 0x8d53;
2819 + static RENDERBUFFER_DEPTH_SIZE: 0x8d54;
2820 + RENDERBUFFER_DEPTH_SIZE: 0x8d54;
2821 + static RENDERBUFFER_STENCIL_SIZE: 0x8d55;
2822 + RENDERBUFFER_STENCIL_SIZE: 0x8d55;
2823 + static FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8cd0;
2824 + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8cd0;
2825 + static FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8cd1;
2826 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8cd1;
2827 + static FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8cd2;
2828 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8cd2;
2829 + static FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8cd3;
2830 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8cd3;
2831 + static COLOR_ATTACHMENT0: 0x8ce0;
2832 + COLOR_ATTACHMENT0: 0x8ce0;
2833 + static DEPTH_ATTACHMENT: 0x8d00;
2834 + DEPTH_ATTACHMENT: 0x8d00;
2835 + static STENCIL_ATTACHMENT: 0x8d20;
2836 + STENCIL_ATTACHMENT: 0x8d20;
2837 + static DEPTH_STENCIL_ATTACHMENT: 0x821a;
2838 + DEPTH_STENCIL_ATTACHMENT: 0x821a;
2839 + static NONE: 0;
2840 + NONE: 0;
2841 + static FRAMEBUFFER_COMPLETE: 0x8cd5;
2842 + FRAMEBUFFER_COMPLETE: 0x8cd5;
2843 + static FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6;
2844 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6;
2845 + static FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7;
2846 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7;
2847 + static FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9;
2848 + FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9;
2849 + static FRAMEBUFFER_UNSUPPORTED: 0x8cdd;
2850 + FRAMEBUFFER_UNSUPPORTED: 0x8cdd;
2851 + static FRAMEBUFFER_BINDING: 0x8ca6;
2852 + FRAMEBUFFER_BINDING: 0x8ca6;
2853 + static RENDERBUFFER_BINDING: 0x8ca7;
2854 + RENDERBUFFER_BINDING: 0x8ca7;
2855 + static MAX_RENDERBUFFER_SIZE: 0x84e8;
2856 + MAX_RENDERBUFFER_SIZE: 0x84e8;
2857 + static INVALID_FRAMEBUFFER_OPERATION: 0x0506;
2858 + INVALID_FRAMEBUFFER_OPERATION: 0x0506;
2859 + static UNPACK_FLIP_Y_WEBGL: 0x9240;
2860 + UNPACK_FLIP_Y_WEBGL: 0x9240;
2861 + static UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241;
2862 + UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241;
2863 + static CONTEXT_LOST_WEBGL: 0x9242;
2864 + CONTEXT_LOST_WEBGL: 0x9242;
2865 + static UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243;
2866 + UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243;
2867 + static BROWSER_DEFAULT_WEBGL: 0x9244;
2868 + BROWSER_DEFAULT_WEBGL: 0x9244;
2869 +
2870 + canvas: HTMLCanvasElement;
2871 + drawingBufferWidth: number;
2872 + drawingBufferHeight: number;
2873 +
2874 + getContextAttributes(): ?WebGLContextAttributes;
2875 + isContextLost(): boolean;
2876 +
2877 + getSupportedExtensions(): ?Array<string>;
2878 + getExtension(name: string): any;
2879 +
2880 + activeTexture(texture: number): void;
2881 + attachShader(program: WebGLProgram, shader: WebGLShader): void;
2882 + bindAttribLocation(program: WebGLProgram, index: number, name: string): void;
2883 + bindBuffer(target: number, buffer: ?WebGLBuffer): void;
2884 + bindFramebuffer(target: number, framebuffer: ?WebGLFramebuffer): void;
2885 + bindRenderbuffer(target: number, renderbuffer: ?WebGLRenderbuffer): void;
2886 + bindTexture(target: number, texture: ?WebGLTexture): void;
2887 + blendColor(red: number, green: number, blue: number, alpha: number): void;
2888 + blendEquation(mode: number): void;
2889 + blendEquationSeparate(modeRGB: number, modeAlpha: number): void;
2890 + blendFunc(sfactor: number, dfactor: number): void;
2891 + blendFuncSeparate(
2892 + srcRGB: number,
2893 + dstRGB: number,
2894 + srcAlpha: number,
2895 + dstAlpha: number
2896 + ): void;
2897 +
2898 + bufferData(target: number, size: number, usage: number): void;
2899 + bufferData(target: number, data: ?ArrayBuffer, usage: number): void;
2900 + bufferData(target: number, data: $ArrayBufferView, usage: number): void;
2901 + bufferSubData(target: number, offset: number, data: BufferDataSource): void;
2902 +
2903 + checkFramebufferStatus(target: number): number;
2904 + clear(mask: number): void;
2905 + clearColor(red: number, green: number, blue: number, alpha: number): void;
2906 + clearDepth(depth: number): void;
2907 + clearStencil(s: number): void;
2908 + colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
2909 + compileShader(shader: WebGLShader): void;
2910 +
2911 + compressedTexImage2D(
2912 + target: number,
2913 + level: number,
2914 + internalformat: number,
2915 + width: number,
2916 + height: number,
2917 + border: number,
2918 + data: $ArrayBufferView
2919 + ): void;
2920 +
2921 + compressedTexSubImage2D(
2922 + target: number,
2923 + level: number,
2924 + xoffset: number,
2925 + yoffset: number,
2926 + width: number,
2927 + height: number,
2928 + format: number,
2929 + data: $ArrayBufferView
2930 + ): void;
2931 +
2932 + copyTexImage2D(
2933 + target: number,
2934 + level: number,
2935 + internalformat: number,
2936 + x: number,
2937 + y: number,
2938 + width: number,
2939 + height: number,
2940 + border: number
2941 + ): void;
2942 + copyTexSubImage2D(
2943 + target: number,
2944 + level: number,
2945 + xoffset: number,
2946 + yoffset: number,
2947 + x: number,
2948 + y: number,
2949 + width: number,
2950 + height: number
2951 + ): void;
2952 +
2953 + createBuffer(): ?WebGLBuffer;
2954 + createFramebuffer(): ?WebGLFramebuffer;
2955 + createProgram(): ?WebGLProgram;
2956 + createRenderbuffer(): ?WebGLRenderbuffer;
2957 + createShader(type: number): ?WebGLShader;
2958 + createTexture(): ?WebGLTexture;
2959 +
2960 + cullFace(mode: number): void;
2961 +
2962 + deleteBuffer(buffer: ?WebGLBuffer): void;
2963 + deleteFramebuffer(framebuffer: ?WebGLFramebuffer): void;
2964 + deleteProgram(program: ?WebGLProgram): void;
2965 + deleteRenderbuffer(renderbuffer: ?WebGLRenderbuffer): void;
2966 + deleteShader(shader: ?WebGLShader): void;
2967 + deleteTexture(texture: ?WebGLTexture): void;
2968 +
2969 + depthFunc(func: number): void;
2970 + depthMask(flag: boolean): void;
2971 + depthRange(zNear: number, zFar: number): void;
2972 + detachShader(program: WebGLProgram, shader: WebGLShader): void;
2973 + disable(cap: number): void;
2974 + disableVertexAttribArray(index: number): void;
2975 + drawArrays(mode: number, first: number, count: number): void;
2976 + drawElements(mode: number, count: number, type: number, offset: number): void;
2977 +
2978 + enable(cap: number): void;
2979 + enableVertexAttribArray(index: number): void;
2980 + finish(): void;
2981 + flush(): void;
2982 + framebufferRenderbuffer(
2983 + target: number,
2984 + attachment: number,
2985 + renderbuffertarget: number,
2986 + renderbuffer: ?WebGLRenderbuffer
2987 + ): void;
2988 + framebufferTexture2D(
2989 + target: number,
2990 + attachment: number,
2991 + textarget: number,
2992 + texture: ?WebGLTexture,
2993 + level: number
2994 + ): void;
2995 + frontFace(mode: number): void;
2996 +
2997 + generateMipmap(target: number): void;
2998 +
2999 + getActiveAttrib(program: WebGLProgram, index: number): ?WebGLActiveInfo;
3000 + getActiveUniform(program: WebGLProgram, index: number): ?WebGLActiveInfo;
3001 + getAttachedShaders(program: WebGLProgram): ?Array<WebGLShader>;
3002 +
3003 + getAttribLocation(program: WebGLProgram, name: string): number;
3004 +
3005 + getBufferParameter(target: number, pname: number): any;
3006 + getParameter(pname: number): any;
3007 +
3008 + getError(): number;
3009 +
3010 + getFramebufferAttachmentParameter(
3011 + target: number,
3012 + attachment: number,
3013 + pname: number
3014 + ): any;
3015 + getProgramParameter(program: WebGLProgram, pname: number): any;
3016 + getProgramInfoLog(program: WebGLProgram): ?string;
3017 + getRenderbufferParameter(target: number, pname: number): any;
3018 + getShaderParameter(shader: WebGLShader, pname: number): any;
3019 + getShaderPrecisionFormat(
3020 + shadertype: number,
3021 + precisiontype: number
3022 + ): ?WebGLShaderPrecisionFormat;
3023 + getShaderInfoLog(shader: WebGLShader): ?string;
3024 +
3025 + getShaderSource(shader: WebGLShader): ?string;
3026 +
3027 + getTexParameter(target: number, pname: number): any;
3028 +
3029 + getUniform(program: WebGLProgram, location: WebGLUniformLocation): any;
3030 +
3031 + getUniformLocation(
3032 + program: WebGLProgram,
3033 + name: string
3034 + ): ?WebGLUniformLocation;
3035 +
3036 + getVertexAttrib(index: number, pname: number): any;
3037 +
3038 + getVertexAttribOffset(index: number, pname: number): number;
3039 +
3040 + hint(target: number, mode: number): void;
3041 + isBuffer(buffer: ?WebGLBuffer): boolean;
3042 + isEnabled(cap: number): boolean;
3043 + isFramebuffer(framebuffer: ?WebGLFramebuffer): boolean;
3044 + isProgram(program: ?WebGLProgram): boolean;
3045 + isRenderbuffer(renderbuffer: ?WebGLRenderbuffer): boolean;
3046 + isShader(shader: ?WebGLShader): boolean;
3047 + isTexture(texture: ?WebGLTexture): boolean;
3048 + lineWidth(width: number): void;
3049 + linkProgram(program: WebGLProgram): void;
3050 + pixelStorei(pname: number, param: number): void;
3051 + polygonOffset(factor: number, units: number): void;
3052 +
3053 + readPixels(
3054 + x: number,
3055 + y: number,
3056 + width: number,
3057 + height: number,
3058 + format: number,
3059 + type: number,
3060 + pixels: ?$ArrayBufferView
3061 + ): void;
3062 +
3063 + renderbufferStorage(
3064 + target: number,
3065 + internalformat: number,
3066 + width: number,
3067 + height: number
3068 + ): void;
3069 + sampleCoverage(value: number, invert: boolean): void;
3070 + scissor(x: number, y: number, width: number, height: number): void;
3071 +
3072 + shaderSource(shader: WebGLShader, source: string): void;
3073 +
3074 + stencilFunc(func: number, ref: number, mask: number): void;
3075 + stencilFuncSeparate(
3076 + face: number,
3077 + func: number,
3078 + ref: number,
3079 + mask: number
3080 + ): void;
3081 + stencilMask(mask: number): void;
3082 + stencilMaskSeparate(face: number, mask: number): void;
3083 + stencilOp(fail: number, zfail: number, zpass: number): void;
3084 + stencilOpSeparate(
3085 + face: number,
3086 + fail: number,
3087 + zfail: number,
3088 + zpass: number
3089 + ): void;
3090 +
3091 + texImage2D(
3092 + target: number,
3093 + level: number,
3094 + internalformat: number,
3095 + width: number,
3096 + height: number,
3097 + border: number,
3098 + format: number,
3099 + type: number,
3100 + pixels: ?$ArrayBufferView
3101 + ): void;
3102 + texImage2D(
3103 + target: number,
3104 + level: number,
3105 + internalformat: number,
3106 + format: number,
3107 + type: number,
3108 + source: TexImageSource
3109 + ): void;
3110 +
3111 + texParameterf(target: number, pname: number, param: number): void;
3112 + texParameteri(target: number, pname: number, param: number): void;
3113 +
3114 + texSubImage2D(
3115 + target: number,
3116 + level: number,
3117 + xoffset: number,
3118 + yoffset: number,
3119 + width: number,
3120 + height: number,
3121 + format: number,
3122 + type: number,
3123 + pixels: ?$ArrayBufferView
3124 + ): void;
3125 + texSubImage2D(
3126 + target: number,
3127 + level: number,
3128 + xoffset: number,
3129 + yoffset: number,
3130 + format: number,
3131 + type: number,
3132 + source: TexImageSource
3133 + ): void;
3134 +
3135 + uniform1f(location: ?WebGLUniformLocation, x: number): void;
3136 + uniform1fv(location: ?WebGLUniformLocation, v: Float32Array): void;
3137 + uniform1fv(location: ?WebGLUniformLocation, v: Array<number>): void;
3138 + uniform1fv(location: ?WebGLUniformLocation, v: [number]): void;
3139 + uniform1i(location: ?WebGLUniformLocation, x: number): void;
3140 + uniform1iv(location: ?WebGLUniformLocation, v: Int32Array): void;
3141 + uniform1iv(location: ?WebGLUniformLocation, v: Array<number>): void;
3142 + uniform1iv(location: ?WebGLUniformLocation, v: [number]): void;
3143 + uniform2f(location: ?WebGLUniformLocation, x: number, y: number): void;
3144 + uniform2fv(location: ?WebGLUniformLocation, v: Float32Array): void;
3145 + uniform2fv(location: ?WebGLUniformLocation, v: Array<number>): void;
3146 + uniform2fv(location: ?WebGLUniformLocation, v: [number, number]): void;
3147 + uniform2i(location: ?WebGLUniformLocation, x: number, y: number): void;
3148 + uniform2iv(location: ?WebGLUniformLocation, v: Int32Array): void;
3149 + uniform2iv(location: ?WebGLUniformLocation, v: Array<number>): void;
3150 + uniform2iv(location: ?WebGLUniformLocation, v: [number, number]): void;
3151 + uniform3f(
3152 + location: ?WebGLUniformLocation,
3153 + x: number,
3154 + y: number,
3155 + z: number
3156 + ): void;
3157 + uniform3fv(location: ?WebGLUniformLocation, v: Float32Array): void;
3158 + uniform3fv(location: ?WebGLUniformLocation, v: Array<number>): void;
3159 + uniform3fv(
3160 + location: ?WebGLUniformLocation,
3161 + v: [number, number, number]
3162 + ): void;
3163 + uniform3i(
3164 + location: ?WebGLUniformLocation,
3165 + x: number,
3166 + y: number,
3167 + z: number
3168 + ): void;
3169 + uniform3iv(location: ?WebGLUniformLocation, v: Int32Array): void;
3170 + uniform3iv(location: ?WebGLUniformLocation, v: Array<number>): void;
3171 + uniform3iv(
3172 + location: ?WebGLUniformLocation,
3173 + v: [number, number, number]
3174 + ): void;
3175 + uniform4f(
3176 + location: ?WebGLUniformLocation,
3177 + x: number,
3178 + y: number,
3179 + z: number,
3180 + w: number
3181 + ): void;
3182 + uniform4fv(location: ?WebGLUniformLocation, v: Float32Array): void;
3183 + uniform4fv(location: ?WebGLUniformLocation, v: Array<number>): void;
3184 + uniform4fv(
3185 + location: ?WebGLUniformLocation,
3186 + v: [number, number, number, number]
3187 + ): void;
3188 + uniform4i(
3189 + location: ?WebGLUniformLocation,
3190 + x: number,
3191 + y: number,
3192 + z: number,
3193 + w: number
3194 + ): void;
3195 + uniform4iv(location: ?WebGLUniformLocation, v: Int32Array): void;
3196 + uniform4iv(location: ?WebGLUniformLocation, v: Array<number>): void;
3197 + uniform4iv(
3198 + location: ?WebGLUniformLocation,
3199 + v: [number, number, number, number]
3200 + ): void;
3201 +
3202 + uniformMatrix2fv(
3203 + location: ?WebGLUniformLocation,
3204 + transpose: boolean,
3205 + value: Float32Array
3206 + ): void;
3207 + uniformMatrix2fv(
3208 + location: ?WebGLUniformLocation,
3209 + transpose: boolean,
3210 + value: Array<number>
3211 + ): void;
3212 + uniformMatrix3fv(
3213 + location: ?WebGLUniformLocation,
3214 + transpose: boolean,
3215 + value: Float32Array
3216 + ): void;
3217 + uniformMatrix3fv(
3218 + location: ?WebGLUniformLocation,
3219 + transpose: boolean,
3220 + value: Array<number>
3221 + ): void;
3222 + uniformMatrix4fv(
3223 + location: ?WebGLUniformLocation,
3224 + transpose: boolean,
3225 + value: Float32Array
3226 + ): void;
3227 + uniformMatrix4fv(
3228 + location: ?WebGLUniformLocation,
3229 + transpose: boolean,
3230 + value: Array<number>
3231 + ): void;
3232 +
3233 + useProgram(program: ?WebGLProgram): void;
3234 + validateProgram(program: WebGLProgram): void;
3235 +
3236 + vertexAttrib1f(index: number, x: number): void;
3237 + vertexAttrib1fv(index: number, values: VertexAttribFVSource): void;
3238 + vertexAttrib2f(index: number, x: number, y: number): void;
3239 + vertexAttrib2fv(index: number, values: VertexAttribFVSource): void;
3240 + vertexAttrib3f(index: number, x: number, y: number, z: number): void;
3241 + vertexAttrib3fv(index: number, values: VertexAttribFVSource): void;
3242 + vertexAttrib4f(
3243 + index: number,
3244 + x: number,
3245 + y: number,
3246 + z: number,
3247 + w: number
3248 + ): void;
3249 + vertexAttrib4fv(index: number, values: VertexAttribFVSource): void;
3250 + vertexAttribPointer(
3251 + index: number,
3252 + size: number,
3253 + type: number,
3254 + normalized: boolean,
3255 + stride: number,
3256 + offset: number
3257 + ): void;
3258 +
3259 + viewport(x: number, y: number, width: number, height: number): void;
3260 +}
3261 +
3262 +declare class WebGLContextEvent extends Event {
3263 + statusMessage: string;
3264 +}
3265 +
3266 +declare class MediaKeyStatusMap<BufferDataSource, MediaKeyStatus> {
3267 + @@iterator(): Iterator<[BufferDataSource, MediaKeyStatus]>;
3268 + size: number;
3269 + entries(): Iterator<[BufferDataSource, MediaKeyStatus]>;
3270 + forEach(
3271 + callbackfn: (
3272 + value: MediaKeyStatus,
3273 + key: BufferDataSource,
3274 + map: MediaKeyStatusMap<BufferDataSource, MediaKeyStatus>
3275 + ) => any,
3276 + thisArg?: any
3277 + ): void;
3278 + get(key: BufferDataSource): MediaKeyStatus;
3279 + has(key: BufferDataSource): boolean;
3280 + keys(): Iterator<BufferDataSource>;
3281 + values(): Iterator<MediaKeyStatus>;
3282 +}
3283 +
3284 +declare class MediaKeySession extends EventTarget {
3285 + sessionId: string;
3286 + expiration: number;
3287 + closed: Promise<void>;
3288 + keyStatuses: MediaKeyStatusMap<BufferDataSource, MediaKeyStatus>;
3289 +
3290 + generateRequest(
3291 + initDataType: string,
3292 + initData: BufferDataSource
3293 + ): Promise<void>;
3294 + load(sessionId: string): Promise<boolean>;
3295 + update(response: BufferDataSource): Promise<void>;
3296 + close(): Promise<void>;
3297 + remove(): Promise<void>;
3298 +
3299 + onkeystatuschange: (ev: any) => any;
3300 + onmessage: (ev: any) => any;
3301 +}
3302 +
3303 +declare class MediaKeys {
3304 + createSession(mediaKeySessionType: MediaKeySessionType): MediaKeySession;
3305 + setServerCertificate(serverCertificate: BufferDataSource): Promise<boolean>;
3306 +}
3307 +
3308 +declare class TextRange {
3309 + boundingLeft: number;
3310 + htmlText: string;
3311 + offsetLeft: number;
3312 + boundingWidth: number;
3313 + boundingHeight: number;
3314 + boundingTop: number;
3315 + text: string;
3316 + offsetTop: number;
3317 + moveToPoint(x: number, y: number): void;
3318 + queryCommandValue(cmdID: string): any;
3319 + getBookmark(): string;
3320 + move(unit: string, count?: number): number;
3321 + queryCommandIndeterm(cmdID: string): boolean;
3322 + scrollIntoView(fStart?: boolean): void;
3323 + findText(string: string, count?: number, flags?: number): boolean;
3324 + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
3325 + getBoundingClientRect(): DOMRect;
3326 + moveToBookmark(bookmark: string): boolean;
3327 + isEqual(range: TextRange): boolean;
3328 + duplicate(): TextRange;
3329 + collapse(start?: boolean): void;
3330 + queryCommandText(cmdID: string): string;
3331 + select(): void;
3332 + pasteHTML(html: string): void;
3333 + inRange(range: TextRange): boolean;
3334 + moveEnd(unit: string, count?: number): number;
3335 + getClientRects(): DOMRectList;
3336 + moveStart(unit: string, count?: number): number;
3337 + parentElement(): Element;
3338 + queryCommandState(cmdID: string): boolean;
3339 + compareEndPoints(how: string, sourceRange: TextRange): number;
3340 + execCommandShowHelp(cmdID: string): boolean;
3341 + moveToElementText(element: Element): void;
3342 + expand(Unit: string): boolean;
3343 + queryCommandSupported(cmdID: string): boolean;
3344 + setEndPoint(how: string, SourceRange: TextRange): void;
3345 + queryCommandEnabled(cmdID: string): boolean;
3346 +}
3347 +
3348 +// These types used to exist as a copy of DOMRect/DOMRectList, which is
3349 +// incorrect because there are no ClientRect/ClientRectList globals on the DOM.
3350 +// Keep these as type aliases for backwards compatibility.
3351 +declare type ClientRect = DOMRect;
3352 +declare type ClientRectList = DOMRectList;
3353 +
3354 +// TODO: HTML*Element
3355 +
3356 +declare class DOMImplementation {
3357 + createDocumentType(
3358 + qualifiedName: string,
3359 + publicId: string,
3360 + systemId: string
3361 + ): DocumentType;
3362 + createDocument(
3363 + namespaceURI: string | null,
3364 + qualifiedName: string,
3365 + doctype?: DocumentType | null
3366 + ): Document;
3367 + hasFeature(feature: string, version?: string): boolean;
3368 +
3369 + // non-standard
3370 + createHTMLDocument(title?: string): Document;
3371 +}
3372 +
3373 +declare class DocumentType extends Node {
3374 + name: string;
3375 + notations: NamedNodeMap;
3376 + systemId: string;
3377 + internalSubset: string;
3378 + entities: NamedNodeMap;
3379 + publicId: string;
3380 +
3381 + // from ChildNode interface
3382 + after(...nodes: Array<string | Node>): void;
3383 + before(...nodes: Array<string | Node>): void;
3384 + replaceWith(...nodes: Array<string | Node>): void;
3385 + remove(): void;
3386 +}
3387 +
3388 +declare class CharacterData extends Node {
3389 + length: number;
3390 + data: string;
3391 + deleteData(offset: number, count: number): void;
3392 + replaceData(offset: number, count: number, arg: string): void;
3393 + appendData(arg: string): void;
3394 + insertData(offset: number, arg: string): void;
3395 + substringData(offset: number, count: number): string;
3396 +
3397 + // from ChildNode interface
3398 + after(...nodes: Array<string | Node>): void;
3399 + before(...nodes: Array<string | Node>): void;
3400 + replaceWith(...nodes: Array<string | Node>): void;
3401 + remove(): void;
3402 +}
3403 +
3404 +declare class Text extends CharacterData {
3405 + assignedSlot?: HTMLSlotElement;
3406 + wholeText: string;
3407 + splitText(offset: number): Text;
3408 + replaceWholeText(content: string): Text;
3409 +}
3410 +
3411 +declare class Comment extends CharacterData {
3412 + text: string;
3413 +}
3414 +
3415 +declare class URL {
3416 + static canParse(url: string, base?: string): boolean;
3417 + static createObjectURL(blob: Blob): string;
3418 + static createObjectURL(mediaSource: MediaSource): string;
3419 + static revokeObjectURL(url: string): void;
3420 + static parse(url: string, base?: string): URL | null;
3421 + constructor(url: string, base?: string | URL): void;
3422 + hash: string;
3423 + host: string;
3424 + hostname: string;
3425 + href: string;
3426 + +origin: string;
3427 + password: string;
3428 + pathname: string;
3429 + port: string;
3430 + protocol: string;
3431 + search: string;
3432 + +searchParams: URLSearchParams;
3433 + username: string;
3434 + toString(): string;
3435 + toJSON(): string;
3436 +}
3437 +
3438 +declare interface MediaSourceHandle {}
3439 +
3440 +declare class MediaSource extends EventTarget {
3441 + sourceBuffers: SourceBufferList;
3442 + activeSourceBuffers: SourceBufferList;
3443 + // https://w3c.github.io/media-source/#dom-readystate
3444 + readyState: 'closed' | 'open' | 'ended';
3445 + duration: number;
3446 + handle: MediaSourceHandle;
3447 + addSourceBuffer(type: string): SourceBuffer;
3448 + removeSourceBuffer(sourceBuffer: SourceBuffer): void;
3449 + endOfStream(error?: string): void;
3450 + static isTypeSupported(type: string): boolean;
3451 +}
3452 +
3453 +declare class SourceBuffer extends EventTarget {
3454 + mode: 'segments' | 'sequence';
3455 + updating: boolean;
3456 + buffered: TimeRanges;
3457 + timestampOffset: number;
3458 + audioTracks: AudioTrackList;
3459 + videoTracks: VideoTrackList;
3460 + textTracks: TextTrackList;
3461 + appendWindowStart: number;
3462 + appendWindowEnd: number;
3463 +
3464 + appendBuffer(data: ArrayBuffer | $ArrayBufferView): void;
3465 + // TODO: Add ReadableStream
3466 + // appendStream(stream: ReadableStream, maxSize?: number): void;
3467 + abort(): void;
3468 + remove(start: number, end: number): void;
3469 +
3470 + trackDefaults: TrackDefaultList;
3471 +}
3472 +
3473 +declare class SourceBufferList extends EventTarget {
3474 + @@iterator(): Iterator<SourceBuffer>;
3475 + [index: number]: SourceBuffer;
3476 + length: number;
3477 +}
3478 +
3479 +declare class TrackDefaultList {
3480 + [index: number]: TrackDefault;
3481 + length: number;
3482 +}
3483 +
3484 +declare class TrackDefault {
3485 + type: 'audio' | 'video' | 'text';
3486 + byteStreamTrackID: string;
3487 + language: string;
3488 + label: string;
3489 + kinds: Array<string>;
3490 +}
3491 +
3492 +// TODO: The use of `typeof` makes this function signature effectively
3493 +// (node: Node) => number, but it should be (node: Node) => 1|2|3
3494 +type NodeFilterCallback = (
3495 + node: Node
3496 +) =>
3497 + | typeof NodeFilter.FILTER_ACCEPT
3498 + | typeof NodeFilter.FILTER_REJECT
3499 + | typeof NodeFilter.FILTER_SKIP;
3500 +
3501 +type NodeFilterInterface =
3502 + | NodeFilterCallback
3503 + | {acceptNode: NodeFilterCallback, ...};
3504 +
3505 +// TODO: window.NodeFilter exists at runtime and behaves as a constructor
3506 +// as far as `instanceof` is concerned, but it is not callable.
3507 +declare class NodeFilter {
3508 + static SHOW_ALL: -1;
3509 + static SHOW_ELEMENT: 1;
3510 + static SHOW_ATTRIBUTE: 2; // deprecated
3511 + static SHOW_TEXT: 4;
3512 + static SHOW_CDATA_SECTION: 8; // deprecated
3513 + static SHOW_ENTITY_REFERENCE: 16; // deprecated
3514 + static SHOW_ENTITY: 32; // deprecated
3515 + static SHOW_PROCESSING_INSTRUCTION: 64;
3516 + static SHOW_COMMENT: 128;
3517 + static SHOW_DOCUMENT: 256;
3518 + static SHOW_DOCUMENT_TYPE: 512;
3519 + static SHOW_DOCUMENT_FRAGMENT: 1024;
3520 + static SHOW_NOTATION: 2048; // deprecated
3521 + static FILTER_ACCEPT: 1;
3522 + static FILTER_REJECT: 2;
3523 + static FILTER_SKIP: 3;
3524 + acceptNode: NodeFilterCallback;
3525 +}
3526 +
3527 +// TODO: window.NodeIterator exists at runtime and behaves as a constructor
3528 +// as far as `instanceof` is concerned, but it is not callable.
3529 +declare class NodeIterator<RootNodeT, WhatToShowT> {
3530 + root: RootNodeT;
3531 + whatToShow: number;
3532 + filter: NodeFilter;
3533 + expandEntityReferences: boolean;
3534 + referenceNode: RootNodeT | WhatToShowT;
3535 + pointerBeforeReferenceNode: boolean;
3536 + detach(): void;
3537 + previousNode(): WhatToShowT | null;
3538 + nextNode(): WhatToShowT | null;
3539 +}
3540 +
3541 +// TODO: window.TreeWalker exists at runtime and behaves as a constructor
3542 +// as far as `instanceof` is concerned, but it is not callable.
3543 +declare class TreeWalker<RootNodeT, WhatToShowT> {
3544 + root: RootNodeT;
3545 + whatToShow: number;
3546 + filter: NodeFilter;
3547 + expandEntityReferences: boolean;
3548 + currentNode: RootNodeT | WhatToShowT;
3549 + parentNode(): WhatToShowT | null;
3550 + firstChild(): WhatToShowT | null;
3551 + lastChild(): WhatToShowT | null;
3552 + previousSibling(): WhatToShowT | null;
3553 + nextSibling(): WhatToShowT | null;
3554 + previousNode(): WhatToShowT | null;
3555 + nextNode(): WhatToShowT | null;
3556 +}
3557 +
3558 +/* Window file picker */
3559 +
3560 +type WindowFileSystemPickerFileType = {|
3561 + description?: string,
3562 + /*
3563 + * An Object with the keys set to the MIME type
3564 + * and the values an Array of file extensions
3565 + * Example:
3566 + * accept: {
3567 + * "image/*": [".png", ".gif", ".jpeg", ".jpg"],
3568 + * },
3569 + */
3570 + accept: {
3571 + [string]: Array<string>,
3572 + },
3573 +|};
3574 +
3575 +type WindowBaseFilePickerOptions = {|
3576 + id?: number,
3577 + startIn?:
3578 + | FileSystemHandle
3579 + | 'desktop'
3580 + | 'documents'
3581 + | 'downloads'
3582 + | 'music'
3583 + | 'pictures'
3584 + | 'videos',
3585 +|};
3586 +
3587 +type WindowFilePickerOptions = WindowBaseFilePickerOptions & {|
3588 + excludeAcceptAllOption?: boolean,
3589 + types?: Array<WindowFileSystemPickerFileType>,
3590 +|};
3591 +
3592 +type WindowOpenFilePickerOptions = WindowFilePickerOptions & {|
3593 + multiple?: boolean,
3594 +|};
3595 +
3596 +type WindowSaveFilePickerOptions = WindowFilePickerOptions & {|
3597 + suggestedName?: string,
3598 +|};
3599 +
3600 +type WindowDirectoryFilePickerOptions = WindowBaseFilePickerOptions & {|
3601 + mode?: 'read' | 'readwrite',
3602 +|};
3603 +
3604 +// https://wicg.github.io/file-system-access/#api-showopenfilepicker
3605 +declare function showOpenFilePicker(
3606 + options?: WindowOpenFilePickerOptions
3607 +): Promise<Array<FileSystemFileHandle>>;
3608 +
3609 +// https://wicg.github.io/file-system-access/#api-showsavefilepicker
3610 +declare function showSaveFilePicker(
3611 + options?: WindowSaveFilePickerOptions
3612 +): Promise<FileSystemFileHandle>;
3613 +
3614 +// https://wicg.github.io/file-system-access/#api-showdirectorypicker
3615 +declare function showDirectoryPicker(
3616 + options?: WindowDirectoryFilePickerOptions
3617 +): Promise<FileSystemDirectoryHandle>;
3618 +
3619 +/* Notification */
3620 +type NotificationPermission = 'default' | 'denied' | 'granted';
3621 +type NotificationDirection = 'auto' | 'ltr' | 'rtl';
3622 +type VibratePattern = number | Array<number>;
3623 +type NotificationAction = {
3624 + action: string,
3625 + title: string,
3626 + icon?: string,
3627 + ...
3628 +};
3629 +type NotificationOptions = {
3630 + dir?: NotificationDirection,
3631 + lang?: string,
3632 + body?: string,
3633 + tag?: string,
3634 + image?: string,
3635 + icon?: string,
3636 + badge?: string,
3637 + sound?: string,
3638 + vibrate?: VibratePattern,
3639 + timestamp?: number,
3640 + renotify?: boolean,
3641 + silent?: boolean,
3642 + requireInteraction?: boolean,
3643 + data?: ?any,
3644 + actions?: Array<NotificationAction>,
3645 + ...
3646 +};
3647 +
3648 +declare class Notification extends EventTarget {
3649 + constructor(title: string, options?: NotificationOptions): void;
3650 + static +permission: NotificationPermission;
3651 + static requestPermission(
3652 + callback?: (perm: NotificationPermission) => mixed
3653 + ): Promise<NotificationPermission>;
3654 + static +maxActions: number;
3655 + onclick: ?(evt: Event) => mixed;
3656 + onclose: ?(evt: Event) => mixed;
3657 + onerror: ?(evt: Event) => mixed;
3658 + onshow: ?(evt: Event) => mixed;
3659 + +title: string;
3660 + +dir: NotificationDirection;
3661 + +lang: string;
3662 + +body: string;
3663 + +tag: string;
3664 + +image?: string;
3665 + +icon?: string;
3666 + +badge?: string;
3667 + +vibrate?: Array<number>;
3668 + +timestamp: number;
3669 + +renotify: boolean;
3670 + +silent: boolean;
3671 + +requireInteraction: boolean;
3672 + +data: any;
3673 + +actions: Array<NotificationAction>;
3674 +
3675 + close(): void;
3676 +}
flow-typed/environments/geometry.js new
+270
@@ -0,0 +1,270 @@
1 +// flow-typed signature: c29a716c1825927cdfc3ad29fe929754
2 +// flow-typed version: 52ab99c6db/geometry/flow_>=v0.261.x
3 +
4 +// https://www.w3.org/TR/geometry-1/
5 +
6 +type DOMMatrix2DInit =
7 + | {|
8 + a: number,
9 + b: number,
10 + c: number,
11 + d: number,
12 + e: number,
13 + f: number,
14 + |}
15 + | {|
16 + m11: number,
17 + m12: number,
18 + m21: number,
19 + m22: number,
20 + m41: number,
21 + m42: number,
22 + |};
23 +
24 +type DOMMatrixInit =
25 + | {|
26 + ...DOMMatrix2DInit,
27 + is2D: true,
28 + |}
29 + | {|
30 + ...DOMMatrix2DInit,
31 + is2D: false,
32 + m13: number,
33 + m14: number,
34 + m23: number,
35 + m24: number,
36 + m31: number,
37 + m32: number,
38 + m33: number,
39 + m34: number,
40 + m43: number,
41 + m44: number,
42 + |};
43 +
44 +type DOMPointInit = {|
45 + w: number,
46 + x: number,
47 + y: number,
48 + z: number,
49 +|};
50 +
51 +type DOMQuadInit = {|
52 + p1: DOMPointInit,
53 + p2: DOMPointInit,
54 + p3: DOMPointInit,
55 + p4: DOMPointInit,
56 +|};
57 +
58 +type DOMRectInit = {|
59 + height: number,
60 + width: number,
61 + x: number,
62 + y: number,
63 +|};
64 +
65 +declare class DOMMatrix extends DOMMatrixReadOnly {
66 + a: number;
67 + b: number;
68 + c: number;
69 + d: number;
70 + e: number;
71 + f: number;
72 + m11: number;
73 + m12: number;
74 + m13: number;
75 + m14: number;
76 + m21: number;
77 + m22: number;
78 + m23: number;
79 + m24: number;
80 + m31: number;
81 + m32: number;
82 + m33: number;
83 + m34: number;
84 + m41: number;
85 + m42: number;
86 + m43: number;
87 + m44: number;
88 +
89 + static fromFloat32Array(array32: Float32Array): DOMMatrix;
90 + static fromFloat64Array(array64: Float64Array): DOMMatrix;
91 + static fromMatrix(other?: DOMMatrixInit): DOMMatrix;
92 +
93 + constructor(init?: string | Array<number>): void;
94 + invertSelf(): DOMMatrix;
95 + multiplySelf(other?: DOMMatrixInit): DOMMatrix;
96 + preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;
97 + rotateAxisAngleSelf(
98 + x?: number,
99 + y?: number,
100 + z?: number,
101 + angle?: number
102 + ): DOMMatrix;
103 + rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;
104 + rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
105 + scale3dSelf(
106 + scale?: number,
107 + originX?: number,
108 + originY?: number,
109 + originZ?: number
110 + ): DOMMatrix;
111 + scaleSelf(
112 + scaleX?: number,
113 + scaleY?: number,
114 + scaleZ?: number,
115 + originX?: number,
116 + originY?: number,
117 + originZ?: number
118 + ): DOMMatrix;
119 + setMatrixValue(transformList: string): DOMMatrix;
120 + skewXSelf(sx?: number): DOMMatrix;
121 + skewYSelf(sy?: number): DOMMatrix;
122 + translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;
123 +}
124 +
125 +declare class DOMMatrixReadOnly {
126 + +a: number;
127 + +b: number;
128 + +c: number;
129 + +d: number;
130 + +e: number;
131 + +f: number;
132 + +is2D: boolean;
133 + +isIdentity: boolean;
134 + +m11: number;
135 + +m12: number;
136 + +m13: number;
137 + +m14: number;
138 + +m21: number;
139 + +m22: number;
140 + +m23: number;
141 + +m24: number;
142 + +m31: number;
143 + +m32: number;
144 + +m33: number;
145 + +m34: number;
146 + +m41: number;
147 + +m42: number;
148 + +m43: number;
149 + +m44: number;
150 +
151 + static fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;
152 + static fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;
153 + static fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;
154 +
155 + constructor(init?: string | Array<number>): void;
156 + flipX(): DOMMatrix;
157 + flipY(): DOMMatrix;
158 + inverse(): DOMMatrix;
159 + multiply(other?: DOMMatrixInit): DOMMatrix;
160 + rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;
161 + rotateAxisAngle(
162 + x?: number,
163 + y?: number,
164 + z?: number,
165 + angle?: number
166 + ): DOMMatrix;
167 + rotateFromVector(x?: number, y?: number): DOMMatrix;
168 + scale(
169 + scaleX?: number,
170 + scaleY?: number,
171 + scaleZ?: number,
172 + originX?: number,
173 + originY?: number,
174 + originZ?: number
175 + ): DOMMatrix;
176 + scale3d(
177 + scale?: number,
178 + originX?: number,
179 + originY?: number,
180 + originZ?: number
181 + ): DOMMatrix;
182 + scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;
183 + skewX(sx?: number): DOMMatrix;
184 + skewY(sy?: number): DOMMatrix;
185 + toFloat32Array(): Float32Array;
186 + toFloat64Array(): Float64Array;
187 + toJSON(): Object;
188 + transformPoint(point?: DOMPointInit): DOMPoint;
189 + translate(tx?: number, ty?: number, tz?: number): DOMMatrix;
190 + toString(): string;
191 +}
192 +
193 +declare class DOMPoint extends DOMPointReadOnly {
194 + w: number;
195 + x: number;
196 + y: number;
197 + z: number;
198 +
199 + static fromPoint(other?: DOMPointInit): DOMPoint;
200 +
201 + constructor(x?: number, y?: number, z?: number, w?: number): void;
202 +}
203 +
204 +declare class DOMPointReadOnly {
205 + +w: number;
206 + +x: number;
207 + +y: number;
208 + +z: number;
209 +
210 + static fromPoint(other?: DOMPointInit): DOMPointReadOnly;
211 +
212 + constructor(x?: number, y?: number, z?: number, w?: number): void;
213 + matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
214 + toJSON(): Object;
215 +}
216 +
217 +declare class DOMQuad {
218 + +p1: DOMPoint;
219 + +p2: DOMPoint;
220 + +p3: DOMPoint;
221 + +p4: DOMPoint;
222 +
223 + static fromQuad(other?: DOMQuadInit): DOMQuad;
224 + static fromRect(other?: DOMRectInit): DOMQuad;
225 +
226 + constructor(
227 + p1?: DOMPointInit,
228 + p2?: DOMPointInit,
229 + p3?: DOMPointInit,
230 + p4?: DOMPointInit
231 + ): void;
232 + getBounds(): DOMRect;
233 + toJSON(): Object;
234 +}
235 +
236 +declare class DOMRect extends DOMRectReadOnly {
237 + height: number;
238 + width: number;
239 + x: number;
240 + y: number;
241 +
242 + constructor(x?: number, y?: number, width?: number, height?: number): void;
243 +
244 + static fromRect(other?: DOMRectInit): DOMRect;
245 +}
246 +
247 +declare class DOMRectList {
248 + +length: number;
249 +
250 + @@iterator(): Iterator<DOMRect>;
251 +
252 + item(index: number): DOMRect;
253 + [index: number]: DOMRect;
254 +}
255 +
256 +declare class DOMRectReadOnly {
257 + +bottom: number;
258 + +height: number;
259 + +left: number;
260 + +right: number;
261 + +top: number;
262 + +width: number;
263 + +x: number;
264 + +y: number;
265 +
266 + constructor(x?: number, y?: number, width?: number, height?: number): void;
267 +
268 + static fromRect(other?: DOMRectInit): DOMRectReadOnly;
269 + toJSON(): Object;
270 +}
flow-typed/environments/html.js new
+1710
@@ -0,0 +1,1710 @@
1 +// flow-typed signature: 760aeea3b9b767e808097fe22b68a20f
2 +// flow-typed version: 8584579196/html/flow_>=v0.261.x
3 +
4 +/* DataTransfer */
5 +
6 +declare class DataTransfer {
7 + clearData(format?: string): void;
8 + getData(format: string): string;
9 + setData(format: string, data: string): void;
10 + setDragImage(image: Element, x: number, y: number): void;
11 + dropEffect: string;
12 + effectAllowed: string;
13 + files: FileList; // readonly
14 + items: DataTransferItemList; // readonly
15 + types: Array<string>; // readonly
16 +}
17 +
18 +declare class DataTransferItemList {
19 + @@iterator(): Iterator<DataTransferItem>;
20 + length: number; // readonly
21 + [index: number]: DataTransferItem;
22 + add(data: string, type: string): ?DataTransferItem;
23 + add(data: File): ?DataTransferItem;
24 + remove(index: number): void;
25 + clear(): void;
26 +}
27 +
28 +// https://wicg.github.io/file-system-access/#drag-and-drop
29 +declare class DataTransferItem {
30 + kind: string; // readonly
31 + type: string; // readonly
32 + getAsString(_callback: ?(data: string) => mixed): void;
33 + getAsFile(): ?File;
34 + /*
35 + * This is not supported by all browsers, please have a fallback plan for it.
36 + * For more information, please checkout
37 + * https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/webkitGetAsEntry
38 + */
39 + webkitGetAsEntry(): void | (() => any);
40 + /*
41 + * Not supported in all browsers
42 + * For up to date compatibility information, please visit
43 + * https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsFileSystemHandle
44 + */
45 + getAsFileSystemHandle?: () => Promise<?FileSystemHandle>;
46 +}
47 +
48 +declare type DOMStringMap = {[key: string]: string, ...};
49 +
50 +declare class DOMStringList {
51 + @@iterator(): Iterator<string>;
52 + +[key: number]: string;
53 + +length: number;
54 + item(number): string | null;
55 + contains(string): boolean;
56 +}
57 +
58 +declare type ElementDefinitionOptions = {|extends?: string|};
59 +
60 +declare interface CustomElementRegistry {
61 + define(
62 + name: string,
63 + ctor: Class<Element>,
64 + options?: ElementDefinitionOptions
65 + ): void;
66 + get(name: string): any;
67 + whenDefined(name: string): Promise<void>;
68 +}
69 +
70 +// https://www.w3.org/TR/eventsource/
71 +declare class EventSource extends EventTarget {
72 + constructor(
73 + url: string,
74 + configuration?: {withCredentials: boolean, ...}
75 + ): void;
76 + +CLOSED: 2;
77 + +CONNECTING: 0;
78 + +OPEN: 1;
79 + +readyState: 0 | 1 | 2;
80 + +url: string;
81 + +withCredentials: boolean;
82 + onerror: () => void;
83 + onmessage: MessageEventListener;
84 + onopen: () => void;
85 + close: () => void;
86 +}
87 +
88 +// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
89 +declare class ErrorEvent extends Event {
90 + constructor(
91 + type: string,
92 + eventInitDict?: {
93 + ...Event$Init,
94 + message?: string,
95 + filename?: string,
96 + lineno?: number,
97 + colno?: number,
98 + error?: any,
99 + ...
100 + }
101 + ): void;
102 + +message: string;
103 + +filename: string;
104 + +lineno: number;
105 + +colno: number;
106 + +error: any;
107 +}
108 +
109 +// https://html.spec.whatwg.org/multipage/web-messaging.html#broadcasting-to-other-browsing-contexts
110 +declare class BroadcastChannel extends EventTarget {
111 + name: string;
112 + onmessage: ?(event: MessageEvent) => void;
113 + onmessageerror: ?(event: MessageEvent) => void;
114 +
115 + constructor(name: string): void;
116 + postMessage(msg: mixed): void;
117 + close(): void;
118 +}
119 +
120 +// https://www.w3.org/TR/webstorage/#the-storageevent-interface
121 +declare class StorageEvent extends Event {
122 + key: ?string;
123 + oldValue: ?string;
124 + newValue: ?string;
125 + url: string;
126 + storageArea: ?Storage;
127 +}
128 +
129 +// https://www.w3.org/TR/html50/browsers.html#beforeunloadevent
130 +declare class BeforeUnloadEvent extends Event {
131 + returnValue: string;
132 +}
133 +
134 +type ToggleEvent$Init = {
135 + ...Event$Init,
136 + oldState: string,
137 + newState: string,
138 + ...
139 +};
140 +
141 +declare class ToggleEvent extends Event {
142 + constructor(type: ToggleEventTypes, eventInit?: ToggleEvent$Init): void;
143 + +oldState: string;
144 + +newState: string;
145 +}
146 +
147 +// TODO: HTMLDocument
148 +type FocusOptions = {preventScroll?: boolean, ...};
149 +
150 +declare class HTMLElement extends Element {
151 + blur(): void;
152 + click(): void;
153 + focus(options?: FocusOptions): void;
154 + getBoundingClientRect(): DOMRect;
155 + forceSpellcheck(): void;
156 +
157 + showPopover(options?: {|source?: HTMLElement|}): void;
158 + hidePopover(): void;
159 + togglePopover(
160 + options?: boolean | {|force?: boolean, source?: HTMLElement|}
161 + ): boolean;
162 +
163 + accessKey: string;
164 + accessKeyLabel: string;
165 + contentEditable: string;
166 + contextMenu: ?HTMLMenuElement;
167 + dataset: DOMStringMap;
168 + dir: 'ltr' | 'rtl' | 'auto';
169 + draggable: boolean;
170 + dropzone: any;
171 + hidden: boolean;
172 + inert: boolean;
173 + isContentEditable: boolean;
174 + itemProp: any;
175 + itemScope: boolean;
176 + itemType: any;
177 + itemValue: Object;
178 + lang: string;
179 + offsetHeight: number;
180 + offsetLeft: number;
181 + offsetParent: ?Element;
182 + offsetTop: number;
183 + offsetWidth: number;
184 + onabort: ?Function;
185 + onblur: ?Function;
186 + oncancel: ?Function;
187 + oncanplay: ?Function;
188 + oncanplaythrough: ?Function;
189 + onchange: ?Function;
190 + onclick: ?Function;
191 + oncontextmenu: ?Function;
192 + oncuechange: ?Function;
193 + ondblclick: ?Function;
194 + ondurationchange: ?Function;
195 + onemptied: ?Function;
196 + onended: ?Function;
197 + onerror: ?Function;
198 + onfocus: ?Function;
199 + onfullscreenchange: ?Function;
200 + onfullscreenerror: ?Function;
201 + ongotpointercapture: ?Function;
202 + oninput: ?Function;
203 + oninvalid: ?Function;
204 + onkeydown: ?Function;
205 + onkeypress: ?Function;
206 + onkeyup: ?Function;
207 + onload: ?Function;
208 + onloadeddata: ?Function;
209 + onloadedmetadata: ?Function;
210 + onloadstart: ?Function;
211 + onlostpointercapture: ?Function;
212 + onmousedown: ?Function;
213 + onmouseenter: ?Function;
214 + onmouseleave: ?Function;
215 + onmousemove: ?Function;
216 + onmouseout: ?Function;
217 + onmouseover: ?Function;
218 + onmouseup: ?Function;
219 + onmousewheel: ?Function;
220 + onpause: ?Function;
221 + onplay: ?Function;
222 + onplaying: ?Function;
223 + onpointercancel: ?Function;
224 + onpointerdown: ?Function;
225 + onpointerenter: ?Function;
226 + onpointerleave: ?Function;
227 + onpointermove: ?Function;
228 + onpointerout: ?Function;
229 + onpointerover: ?Function;
230 + onpointerup: ?Function;
231 + onprogress: ?Function;
232 + onratechange: ?Function;
233 + onreadystatechange: ?Function;
234 + onreset: ?Function;
235 + onresize: ?Function;
236 + onscroll: ?Function;
237 + onseeked: ?Function;
238 + onseeking: ?Function;
239 + onselect: ?Function;
240 + onshow: ?Function;
241 + onstalled: ?Function;
242 + onsubmit: ?Function;
243 + onsuspend: ?Function;
244 + ontimeupdate: ?Function;
245 + ontoggle: ?Function;
246 + onbeforetoggle: ?Function;
247 + onvolumechange: ?Function;
248 + onwaiting: ?Function;
249 + properties: any;
250 + spellcheck: boolean;
251 + style: CSSStyleDeclaration;
252 + tabIndex: number;
253 + title: string;
254 + translate: boolean;
255 + popover: '' | 'auto' | 'manual' | 'hint';
256 +
257 + +popoverVisibilityState: 'hidden' | 'showing';
258 +
259 + +popoverInvoker: HTMLElement | null;
260 +}
261 +
262 +declare class HTMLSlotElement extends HTMLElement {
263 + name: string;
264 + assignedNodes(options?: {flatten: boolean, ...}): Node[];
265 +}
266 +
267 +declare class HTMLTableElement extends HTMLElement {
268 + tagName: 'TABLE';
269 + caption: HTMLTableCaptionElement | null;
270 + tHead: HTMLTableSectionElement | null;
271 + tFoot: HTMLTableSectionElement | null;
272 + +tBodies: HTMLCollection<HTMLTableSectionElement>;
273 + +rows: HTMLCollection<HTMLTableRowElement>;
274 + createTHead(): HTMLTableSectionElement;
275 + deleteTHead(): void;
276 + createTFoot(): HTMLTableSectionElement;
277 + deleteTFoot(): void;
278 + createCaption(): HTMLTableCaptionElement;
279 + deleteCaption(): void;
280 + insertRow(index?: number): HTMLTableRowElement;
281 + deleteRow(index: number): void;
282 +}
283 +
284 +declare class HTMLTableCaptionElement extends HTMLElement {
285 + tagName: 'CAPTION';
286 +}
287 +
288 +declare class HTMLTableColElement extends HTMLElement {
289 + tagName: 'COL' | 'COLGROUP';
290 + span: number;
291 +}
292 +
293 +declare class HTMLTableSectionElement extends HTMLElement {
294 + tagName: 'THEAD' | 'TFOOT' | 'TBODY';
295 + +rows: HTMLCollection<HTMLTableRowElement>;
296 + insertRow(index?: number): HTMLTableRowElement;
297 + deleteRow(index: number): void;
298 +}
299 +
300 +declare class HTMLTableCellElement extends HTMLElement {
301 + tagName: 'TD' | 'TH';
302 + colSpan: number;
303 + rowSpan: number;
304 + +cellIndex: number;
305 +}
306 +
307 +declare class HTMLTableRowElement extends HTMLElement {
308 + tagName: 'TR';
309 + align: 'left' | 'right' | 'center';
310 + +rowIndex: number;
311 + +sectionRowIndex: number;
312 + +cells: HTMLCollection<HTMLTableCellElement>;
313 + deleteCell(index: number): void;
314 + insertCell(index?: number): HTMLTableCellElement;
315 +}
316 +
317 +declare class HTMLMenuElement extends HTMLElement {
318 + getCompact(): boolean;
319 + setCompact(compact: boolean): void;
320 +}
321 +
322 +declare class HTMLBaseElement extends HTMLElement {
323 + href: string;
324 + target: string;
325 +}
326 +
327 +declare class HTMLTemplateElement extends HTMLElement {
328 + content: DocumentFragment;
329 +}
330 +
331 +declare class CanvasGradient {
332 + addColorStop(offset: number, color: string): void;
333 +}
334 +
335 +declare class CanvasPattern {
336 + setTransform(matrix: SVGMatrix): void;
337 +}
338 +
339 +declare class ImageBitmap {
340 + close(): void;
341 + width: number;
342 + height: number;
343 +}
344 +
345 +type CanvasFillRule = string;
346 +
347 +type CanvasImageSource =
348 + | HTMLImageElement
349 + | HTMLVideoElement
350 + | HTMLCanvasElement
351 + | CanvasRenderingContext2D
352 + | ImageBitmap;
353 +
354 +declare class TextMetrics {
355 + // x-direction
356 + width: number;
357 + actualBoundingBoxLeft: number;
358 + actualBoundingBoxRight: number;
359 +
360 + // y-direction
361 + fontBoundingBoxAscent: number;
362 + fontBoundingBoxDescent: number;
363 + actualBoundingBoxAscent: number;
364 + actualBoundingBoxDescent: number;
365 + emHeightAscent: number;
366 + emHeightDescent: number;
367 + hangingBaseline: number;
368 + alphabeticBaseline: number;
369 + ideographicBaseline: number;
370 +}
371 +
372 +declare class CanvasDrawingStyles {
373 + width: number;
374 + actualBoundingBoxLeft: number;
375 + actualBoundingBoxRight: number;
376 +
377 + // y-direction
378 + fontBoundingBoxAscent: number;
379 + fontBoundingBoxDescent: number;
380 + actualBoundingBoxAscent: number;
381 + actualBoundingBoxDescent: number;
382 + emHeightAscent: number;
383 + emHeightDescent: number;
384 + hangingBaseline: number;
385 + alphabeticBaseline: number;
386 + ideographicBaseline: number;
387 +}
388 +
389 +declare class Path2D {
390 + constructor(path?: Path2D | string): void;
391 +
392 + addPath(path: Path2D, transformation?: ?SVGMatrix): void;
393 + addPathByStrokingPath(
394 + path: Path2D,
395 + styles: CanvasDrawingStyles,
396 + transformation?: ?SVGMatrix
397 + ): void;
398 + addText(
399 + text: string,
400 + styles: CanvasDrawingStyles,
401 + transformation: ?SVGMatrix,
402 + x: number,
403 + y: number,
404 + maxWidth?: number
405 + ): void;
406 + addPathByStrokingText(
407 + text: string,
408 + styles: CanvasDrawingStyles,
409 + transformation: ?SVGMatrix,
410 + x: number,
411 + y: number,
412 + maxWidth?: number
413 + ): void;
414 + addText(
415 + text: string,
416 + styles: CanvasDrawingStyles,
417 + transformation: ?SVGMatrix,
418 + path: Path2D,
419 + maxWidth?: number
420 + ): void;
421 + addPathByStrokingText(
422 + text: string,
423 + styles: CanvasDrawingStyles,
424 + transformation: ?SVGMatrix,
425 + path: Path2D,
426 + maxWidth?: number
427 + ): void;
428 +
429 + // CanvasPathMethods
430 + // shared path API methods
431 + arc(
432 + x: number,
433 + y: number,
434 + radius: number,
435 + startAngle: number,
436 + endAngle: number,
437 + anticlockwise?: boolean
438 + ): void;
439 + arcTo(
440 + x1: number,
441 + y1: number,
442 + x2: number,
443 + y2: number,
444 + radius: number,
445 + _: void,
446 + _: void
447 + ): void;
448 + arcTo(
449 + x1: number,
450 + y1: number,
451 + x2: number,
452 + y2: number,
453 + radiusX: number,
454 + radiusY: number,
455 + rotation: number
456 + ): void;
457 + bezierCurveTo(
458 + cp1x: number,
459 + cp1y: number,
460 + cp2x: number,
461 + cp2y: number,
462 + x: number,
463 + y: number
464 + ): void;
465 + closePath(): void;
466 + ellipse(
467 + x: number,
468 + y: number,
469 + radiusX: number,
470 + radiusY: number,
471 + rotation: number,
472 + startAngle: number,
473 + endAngle: number,
474 + anticlockwise?: boolean
475 + ): void;
476 + lineTo(x: number, y: number): void;
477 + moveTo(x: number, y: number): void;
478 + quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
479 + rect(x: number, y: number, w: number, h: number): void;
480 +}
481 +
482 +declare class ImageData {
483 + width: number;
484 + height: number;
485 + data: Uint8ClampedArray;
486 +
487 + // constructor methods are used in Worker where CanvasRenderingContext2D
488 + // is unavailable.
489 + // https://html.spec.whatwg.org/multipage/scripting.html#dom-imagedata
490 + constructor(data: Uint8ClampedArray, width: number, height: number): void;
491 + constructor(width: number, height: number): void;
492 +}
493 +
494 +declare class CanvasRenderingContext2D {
495 + canvas: HTMLCanvasElement;
496 +
497 + // canvas dimensions
498 + width: number;
499 + height: number;
500 +
501 + // for contexts that aren't directly fixed to a specific canvas
502 + commit(): void;
503 +
504 + // state
505 + save(): void;
506 + restore(): void;
507 +
508 + // transformations
509 + currentTransform: SVGMatrix;
510 + scale(x: number, y: number): void;
511 + rotate(angle: number): void;
512 + translate(x: number, y: number): void;
513 + transform(
514 + a: number,
515 + b: number,
516 + c: number,
517 + d: number,
518 + e: number,
519 + f: number
520 + ): void;
521 + setTransform(
522 + a: number,
523 + b: number,
524 + c: number,
525 + d: number,
526 + e: number,
527 + f: number
528 + ): void;
529 + resetTransform(): void;
530 +
531 + // compositing
532 + globalAlpha: number;
533 + globalCompositeOperation: string;
534 +
535 + // image smoothing
536 + imageSmoothingEnabled: boolean;
537 + imageSmoothingQuality: 'low' | 'medium' | 'high';
538 +
539 + // filters
540 + filter: string;
541 +
542 + // colours and styles
543 + strokeStyle: string | CanvasGradient | CanvasPattern;
544 + fillStyle: string | CanvasGradient | CanvasPattern;
545 + createLinearGradient(
546 + x0: number,
547 + y0: number,
548 + x1: number,
549 + y1: number
550 + ): CanvasGradient;
551 + createRadialGradient(
552 + x0: number,
553 + y0: number,
554 + r0: number,
555 + x1: number,
556 + y1: number,
557 + r1: number
558 + ): CanvasGradient;
559 + createPattern(image: CanvasImageSource, repetition: ?string): CanvasPattern;
560 +
561 + // shadows
562 + shadowOffsetX: number;
563 + shadowOffsetY: number;
564 + shadowBlur: number;
565 + shadowColor: string;
566 +
567 + // rects
568 + clearRect(x: number, y: number, w: number, h: number): void;
569 + fillRect(x: number, y: number, w: number, h: number): void;
570 + roundRect(
571 + x: number,
572 + y: number,
573 + w: number,
574 + h: number,
575 + radii?: number | DOMPointInit | $ReadOnlyArray<number | DOMPointInit>
576 + ): void;
577 + strokeRect(x: number, y: number, w: number, h: number): void;
578 +
579 + // path API
580 + beginPath(): void;
581 + fill(fillRule?: CanvasFillRule): void;
582 + fill(path: Path2D, fillRule?: CanvasFillRule): void;
583 + stroke(): void;
584 + stroke(path: Path2D): void;
585 + drawFocusIfNeeded(element: Element): void;
586 + drawFocusIfNeeded(path: Path2D, element: Element): void;
587 + scrollPathIntoView(): void;
588 + scrollPathIntoView(path: Path2D): void;
589 + clip(fillRule?: CanvasFillRule): void;
590 + clip(path: Path2D, fillRule?: CanvasFillRule): void;
591 + resetClip(): void;
592 + isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
593 + isPointInPath(
594 + path: Path2D,
595 + x: number,
596 + y: number,
597 + fillRule?: CanvasFillRule
598 + ): boolean;
599 + isPointInStroke(x: number, y: number): boolean;
600 + isPointInStroke(path: Path2D, x: number, y: number): boolean;
601 +
602 + // text (see also the CanvasDrawingStyles interface)
603 + fillText(text: string, x: number, y: number, maxWidth?: number): void;
604 + strokeText(text: string, x: number, y: number, maxWidth?: number): void;
605 + measureText(text: string): TextMetrics;
606 +
607 + // drawing images
608 + drawImage(image: CanvasImageSource, dx: number, dy: number): void;
609 + drawImage(
610 + image: CanvasImageSource,
611 + dx: number,
612 + dy: number,
613 + dw: number,
614 + dh: number
615 + ): void;
616 + drawImage(
617 + image: CanvasImageSource,
618 + sx: number,
619 + sy: number,
620 + sw: number,
621 + sh: number,
622 + dx: number,
623 + dy: number,
624 + dw: number,
625 + dh: number
626 + ): void;
627 +
628 + // hit regions
629 + addHitRegion(options?: HitRegionOptions): void;
630 + removeHitRegion(id: string): void;
631 + clearHitRegions(): void;
632 +
633 + // pixel manipulation
634 + createImageData(sw: number, sh: number): ImageData;
635 + createImageData(imagedata: ImageData): ImageData;
636 + getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
637 + putImageData(imagedata: ImageData, dx: number, dy: number): void;
638 + putImageData(
639 + imagedata: ImageData,
640 + dx: number,
641 + dy: number,
642 + dirtyX: number,
643 + dirtyY: number,
644 + dirtyWidth: number,
645 + dirtyHeight: number
646 + ): void;
647 +
648 + // CanvasDrawingStyles
649 + // line caps/joins
650 + lineWidth: number;
651 + lineCap: string;
652 + lineJoin: string;
653 + miterLimit: number;
654 +
655 + // dashed lines
656 + setLineDash(segments: Array<number>): void;
657 + getLineDash(): Array<number>;
658 + lineDashOffset: number;
659 +
660 + // text
661 + font: string;
662 + textAlign: string;
663 + textBaseline: string;
664 + direction: string;
665 +
666 + // CanvasPathMethods
667 + // shared path API methods
668 + closePath(): void;
669 + moveTo(x: number, y: number): void;
670 + lineTo(x: number, y: number): void;
671 + quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
672 + bezierCurveTo(
673 + cp1x: number,
674 + cp1y: number,
675 + cp2x: number,
676 + cp2y: number,
677 + x: number,
678 + y: number
679 + ): void;
680 + arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
681 + arcTo(
682 + x1: number,
683 + y1: number,
684 + x2: number,
685 + y2: number,
686 + radiusX: number,
687 + radiusY: number,
688 + rotation: number
689 + ): void;
690 + rect(x: number, y: number, w: number, h: number): void;
691 + arc(
692 + x: number,
693 + y: number,
694 + radius: number,
695 + startAngle: number,
696 + endAngle: number,
697 + anticlockwise?: boolean
698 + ): void;
699 + ellipse(
700 + x: number,
701 + y: number,
702 + radiusX: number,
703 + radiusY: number,
704 + rotation: number,
705 + startAngle: number,
706 + endAngle: number,
707 + anticlockwise?: boolean
708 + ): void;
709 +}
710 +
711 +// http://www.w3.org/TR/html5/scripting-1.html#renderingcontext
712 +type RenderingContext = CanvasRenderingContext2D | WebGLRenderingContext;
713 +
714 +// https://www.w3.org/TR/html5/scripting-1.html#htmlcanvaselement
715 +declare class HTMLCanvasElement extends HTMLElement {
716 + tagName: 'CANVAS';
717 + width: number;
718 + height: number;
719 + getContext(contextId: '2d', ...args: any): CanvasRenderingContext2D;
720 + getContext(
721 + contextId: 'webgl',
722 + contextAttributes?: Partial<WebGLContextAttributes>
723 + ): ?WebGLRenderingContext;
724 + // IE currently only supports "experimental-webgl"
725 + getContext(
726 + contextId: 'experimental-webgl',
727 + contextAttributes?: Partial<WebGLContextAttributes>
728 + ): ?WebGLRenderingContext;
729 + getContext(contextId: string, ...args: any): ?RenderingContext; // fallback
730 + toDataURL(type?: string, ...args: any): string;
731 + toBlob(callback: (v: File) => void, type?: string, ...args: any): void;
732 + captureStream(frameRate?: number): CanvasCaptureMediaStream;
733 +}
734 +
735 +// https://html.spec.whatwg.org/multipage/forms.html#the-details-element
736 +declare class HTMLDetailsElement extends HTMLElement {
737 + tagName: 'DETAILS';
738 + open: boolean;
739 +}
740 +
741 +declare class HTMLFormElement extends HTMLElement {
742 + tagName: 'FORM';
743 + @@iterator(): Iterator<HTMLElement>;
744 + [index: number | string]: HTMLElement | null;
745 + acceptCharset: string;
746 + action: string;
747 + elements: HTMLCollection<HTMLElement>;
748 + encoding: string;
749 + enctype: string;
750 + length: number;
751 + method: string;
752 + name: string;
753 + rel: string;
754 + target: string;
755 +
756 + checkValidity(): boolean;
757 + reportValidity(): boolean;
758 + reset(): void;
759 + submit(): void;
760 +}
761 +
762 +// https://www.w3.org/TR/html5/forms.html#the-fieldset-element
763 +declare class HTMLFieldSetElement extends HTMLElement {
764 + tagName: 'FIELDSET';
765 + disabled: boolean;
766 + elements: HTMLCollection<HTMLElement>; // readonly
767 + form: HTMLFormElement | null; // readonly
768 + name: string;
769 + type: string; // readonly
770 +
771 + checkValidity(): boolean;
772 + setCustomValidity(error: string): void;
773 +}
774 +
775 +declare class HTMLLegendElement extends HTMLElement {
776 + tagName: 'LEGEND';
777 + form: HTMLFormElement | null; // readonly
778 +}
779 +
780 +declare class HTMLIFrameElement extends HTMLElement {
781 + tagName: 'IFRAME';
782 + allowFullScreen: boolean;
783 + contentDocument: Document;
784 + contentWindow: any;
785 + frameBorder: string;
786 + height: string;
787 + marginHeight: string;
788 + marginWidth: string;
789 + name: string;
790 + scrolling: string;
791 + sandbox: DOMTokenList;
792 + src: string;
793 + // flowlint unsafe-getters-setters:off
794 + get srcdoc(): string;
795 + set srcdoc(value: string | TrustedHTML): void;
796 + // flowlint unsafe-getters-setters:error
797 + width: string;
798 +}
799 +
800 +declare class HTMLImageElement extends HTMLElement {
801 + tagName: 'IMG';
802 + alt: string;
803 + complete: boolean; // readonly
804 + crossOrigin: ?string;
805 + currentSrc: string; // readonly
806 + height: number;
807 + decode(): Promise<void>;
808 + isMap: boolean;
809 + naturalHeight: number; // readonly
810 + naturalWidth: number; // readonly
811 + sizes: string;
812 + src: string;
813 + srcset: string;
814 + useMap: string;
815 + width: number;
816 +}
817 +
818 +declare class Image extends HTMLImageElement {
819 + constructor(width?: number, height?: number): void;
820 +}
821 +
822 +declare class MediaError {
823 + MEDIA_ERR_ABORTED: number;
824 + MEDIA_ERR_NETWORK: number;
825 + MEDIA_ERR_DECODE: number;
826 + MEDIA_ERR_SRC_NOT_SUPPORTED: number;
827 + code: number;
828 + message: ?string;
829 +}
830 +
831 +declare class TimeRanges {
832 + length: number;
833 + start(index: number): number;
834 + end(index: number): number;
835 +}
836 +
837 +declare class Audio extends HTMLAudioElement {
838 + constructor(URLString?: string): void;
839 +}
840 +
841 +declare class AudioTrack {
842 + id: string;
843 + kind: string;
844 + label: string;
845 + language: string;
846 + enabled: boolean;
847 +}
848 +
849 +declare class AudioTrackList extends EventTarget {
850 + length: number;
851 + [index: number]: AudioTrack;
852 +
853 + getTrackById(id: string): ?AudioTrack;
854 +
855 + onchange: (ev: any) => any;
856 + onaddtrack: (ev: any) => any;
857 + onremovetrack: (ev: any) => any;
858 +}
859 +
860 +declare class VideoTrack {
861 + id: string;
862 + kind: string;
863 + label: string;
864 + language: string;
865 + selected: boolean;
866 +}
867 +
868 +declare class VideoTrackList extends EventTarget {
869 + length: number;
870 + [index: number]: VideoTrack;
871 + getTrackById(id: string): ?VideoTrack;
872 + selectedIndex: number;
873 +
874 + onchange: (ev: any) => any;
875 + onaddtrack: (ev: any) => any;
876 + onremovetrack: (ev: any) => any;
877 +}
878 +
879 +declare class TextTrackCue extends EventTarget {
880 + constructor(startTime: number, endTime: number, text: string): void;
881 +
882 + track: TextTrack;
883 + id: string;
884 + startTime: number;
885 + endTime: number;
886 + pauseOnExit: boolean;
887 + vertical: string;
888 + snapToLines: boolean;
889 + lines: number;
890 + position: number;
891 + size: number;
892 + align: string;
893 + text: string;
894 +
895 + getCueAsHTML(): Node;
896 + onenter: (ev: any) => any;
897 + onexit: (ev: any) => any;
898 +}
899 +
900 +declare class TextTrackCueList {
901 + @@iterator(): Iterator<TextTrackCue>;
902 + length: number;
903 + [index: number]: TextTrackCue;
904 + getCueById(id: string): ?TextTrackCue;
905 +}
906 +
907 +declare class TextTrack extends EventTarget {
908 + kind: string;
909 + label: string;
910 + language: string;
911 +
912 + mode: string;
913 +
914 + cues: TextTrackCueList;
915 + activeCues: TextTrackCueList;
916 +
917 + addCue(cue: TextTrackCue): void;
918 + removeCue(cue: TextTrackCue): void;
919 +
920 + oncuechange: (ev: any) => any;
921 +}
922 +
923 +declare class TextTrackList extends EventTarget {
924 + length: number;
925 + [index: number]: TextTrack;
926 +
927 + onaddtrack: (ev: any) => any;
928 + onremovetrack: (ev: any) => any;
929 +}
930 +
931 +declare class HTMLMediaElement extends HTMLElement {
932 + // error state
933 + error: ?MediaError;
934 +
935 + // network state
936 + src: string;
937 + srcObject: ?any;
938 + currentSrc: string;
939 + crossOrigin: ?string;
940 + NETWORK_EMPTY: number;
941 + NETWORK_IDLE: number;
942 + NETWORK_LOADING: number;
943 + NETWORK_NO_SOURCE: number;
944 + networkState: number;
945 + preload: string;
946 + buffered: TimeRanges;
947 + load(): void;
948 + canPlayType(type: string): string;
949 +
950 + // ready state
951 + HAVE_NOTHING: number;
952 + HAVE_METADATA: number;
953 + HAVE_CURRENT_DATA: number;
954 + HAVE_FUTURE_DATA: number;
955 + HAVE_ENOUGH_DATA: number;
956 + readyState: number;
957 + seeking: boolean;
958 +
959 + // playback state
960 + currentTime: number;
961 + duration: number;
962 + startDate: Date;
963 + paused: boolean;
964 + defaultPlaybackRate: number;
965 + playbackRate: number;
966 + played: TimeRanges;
967 + seekable: TimeRanges;
968 + ended: boolean;
969 + autoplay: boolean;
970 + loop: boolean;
971 + play(): Promise<void>;
972 + pause(): void;
973 + fastSeek(): void;
974 + captureStream(): MediaStream;
975 +
976 + // media controller
977 + mediaGroup: string;
978 + controller: ?any;
979 +
980 + // controls
981 + controls: boolean;
982 + volume: number;
983 + muted: boolean;
984 + defaultMuted: boolean;
985 + controlsList?: DOMTokenList;
986 +
987 + // tracks
988 + audioTracks: AudioTrackList;
989 + videoTracks: VideoTrackList;
990 + textTracks: TextTrackList;
991 + addTextTrack(kind: string, label?: string, language?: string): TextTrack;
992 +
993 + // media keys
994 + mediaKeys?: ?MediaKeys;
995 + setMediakeys?: (mediakeys: ?MediaKeys) => Promise<?MediaKeys>;
996 +}
997 +
998 +declare class HTMLAudioElement extends HTMLMediaElement {
999 + tagName: 'AUDIO';
1000 +}
1001 +
1002 +declare class HTMLVideoElement extends HTMLMediaElement {
1003 + tagName: 'VIDEO';
1004 + width: number;
1005 + height: number;
1006 + videoWidth: number;
1007 + videoHeight: number;
1008 + poster: string;
1009 +}
1010 +
1011 +declare class HTMLSourceElement extends HTMLElement {
1012 + tagName: 'SOURCE';
1013 + src: string;
1014 + type: string;
1015 +
1016 + //when used with the picture element
1017 + srcset: string;
1018 + sizes: string;
1019 + media: string;
1020 +}
1021 +
1022 +declare class ValidityState {
1023 + badInput: boolean;
1024 + customError: boolean;
1025 + patternMismatch: boolean;
1026 + rangeOverflow: boolean;
1027 + rangeUnderflow: boolean;
1028 + stepMismatch: boolean;
1029 + tooLong: boolean;
1030 + tooShort: boolean;
1031 + typeMismatch: boolean;
1032 + valueMissing: boolean;
1033 + valid: boolean;
1034 +}
1035 +
1036 +// https://w3c.github.io/html/sec-forms.html#dom-selectionapielements-setselectionrange
1037 +type SelectionDirection = 'backward' | 'forward' | 'none';
1038 +type SelectionMode = 'select' | 'start' | 'end' | 'preserve';
1039 +declare class HTMLInputElement extends HTMLElement {
1040 + tagName: 'INPUT';
1041 + accept: string;
1042 + align: string;
1043 + alt: string;
1044 + autocomplete: string;
1045 + autofocus: boolean;
1046 + border: string;
1047 + checked: boolean;
1048 + complete: boolean;
1049 + defaultChecked: boolean;
1050 + defaultValue: string;
1051 + dirname: string;
1052 + disabled: boolean;
1053 + dynsrc: string;
1054 + files: FileList;
1055 + form: HTMLFormElement | null;
1056 + formAction: string;
1057 + formEncType: string;
1058 + formMethod: string;
1059 + formNoValidate: boolean;
1060 + formTarget: string;
1061 + height: string;
1062 + hspace: number;
1063 + indeterminate: boolean;
1064 + labels: NodeList<HTMLLabelElement>;
1065 + list: HTMLElement | null;
1066 + loop: number;
1067 + lowsrc: string;
1068 + max: string;
1069 + maxLength: number;
1070 + min: string;
1071 + multiple: boolean;
1072 + name: string;
1073 + pattern: string;
1074 + placeholder: string;
1075 + readOnly: boolean;
1076 + required: boolean;
1077 + selectionDirection: SelectionDirection;
1078 + selectionEnd: number;
1079 + selectionStart: number;
1080 + size: number;
1081 + src: string;
1082 + start: string;
1083 + status: boolean;
1084 + step: string;
1085 + type: string;
1086 + useMap: string;
1087 + validationMessage: string;
1088 + validity: ValidityState;
1089 + value: string;
1090 + valueAsDate: Date;
1091 + valueAsNumber: number;
1092 + vrml: string;
1093 + vspace: number;
1094 + width: string;
1095 + willValidate: boolean;
1096 + popoverTargetElement: Element | null;
1097 + popoverTargetAction: 'toggle' | 'show' | 'hide';
1098 +
1099 + checkValidity(): boolean;
1100 + reportValidity(): boolean;
1101 + setCustomValidity(error: string): void;
1102 + createTextRange(): TextRange;
1103 + select(): void;
1104 + setRangeText(
1105 + replacement: string,
1106 + start?: void,
1107 + end?: void,
1108 + selectMode?: void
1109 + ): void;
1110 + setRangeText(
1111 + replacement: string,
1112 + start: number,
1113 + end: number,
1114 + selectMode?: SelectionMode
1115 + ): void;
1116 + setSelectionRange(
1117 + start: number,
1118 + end: number,
1119 + direction?: SelectionDirection
1120 + ): void;
1121 + showPicker(): void;
1122 + stepDown(stepDecrement?: number): void;
1123 + stepUp(stepIncrement?: number): void;
1124 +}
1125 +
1126 +declare class HTMLButtonElement extends HTMLElement {
1127 + tagName: 'BUTTON';
1128 + autofocus: boolean;
1129 + disabled: boolean;
1130 + form: HTMLFormElement | null;
1131 + labels: NodeList<HTMLLabelElement> | null;
1132 + name: string;
1133 + type: string;
1134 + validationMessage: string;
1135 + validity: ValidityState;
1136 + value: string;
1137 + willValidate: boolean;
1138 +
1139 + checkValidity(): boolean;
1140 + reportValidity(): boolean;
1141 + setCustomValidity(error: string): void;
1142 + popoverTargetElement: Element | null;
1143 + popoverTargetAction: 'toggle' | 'show' | 'hide';
1144 +}
1145 +
1146 +// https://w3c.github.io/html/sec-forms.html#the-textarea-element
1147 +declare class HTMLTextAreaElement extends HTMLElement {
1148 + tagName: 'TEXTAREA';
1149 + autofocus: boolean;
1150 + cols: number;
1151 + dirName: string;
1152 + disabled: boolean;
1153 + form: HTMLFormElement | null;
1154 + maxLength: number;
1155 + name: string;
1156 + placeholder: string;
1157 + readOnly: boolean;
1158 + required: boolean;
1159 + rows: number;
1160 + wrap: string;
1161 +
1162 + type: string;
1163 + defaultValue: string;
1164 + value: string;
1165 + textLength: number;
1166 +
1167 + willValidate: boolean;
1168 + validity: ValidityState;
1169 + validationMessage: string;
1170 + checkValidity(): boolean;
1171 + setCustomValidity(error: string): void;
1172 +
1173 + labels: NodeList<HTMLLabelElement>;
1174 +
1175 + select(): void;
1176 + selectionStart: number;
1177 + selectionEnd: number;
1178 + selectionDirection: SelectionDirection;
1179 + setSelectionRange(
1180 + start: number,
1181 + end: number,
1182 + direction?: SelectionDirection
1183 + ): void;
1184 +}
1185 +
1186 +declare class HTMLSelectElement extends HTMLElement {
1187 + tagName: 'SELECT';
1188 + autocomplete: string;
1189 + autofocus: boolean;
1190 + disabled: boolean;
1191 + form: HTMLFormElement | null;
1192 + labels: NodeList<HTMLLabelElement>;
1193 + length: number;
1194 + multiple: boolean;
1195 + name: string;
1196 + options: HTMLOptionsCollection;
1197 + required: boolean;
1198 + selectedIndex: number;
1199 + selectedOptions: HTMLCollection<HTMLOptionElement>;
1200 + size: number;
1201 + type: string;
1202 + validationMessage: string;
1203 + validity: ValidityState;
1204 + value: string;
1205 + willValidate: boolean;
1206 +
1207 + add(element: HTMLElement, before?: HTMLElement): void;
1208 + checkValidity(): boolean;
1209 + item(index: number): HTMLOptionElement | null;
1210 + namedItem(name: string): HTMLOptionElement | null;
1211 + remove(index?: number): void;
1212 + setCustomValidity(error: string): void;
1213 +}
1214 +
1215 +declare class HTMLOptionsCollection extends HTMLCollection<HTMLOptionElement> {
1216 + selectedIndex: number;
1217 + add(
1218 + element: HTMLOptionElement | HTMLOptGroupElement,
1219 + before?: HTMLElement | number
1220 + ): void;
1221 + remove(index: number): void;
1222 +}
1223 +
1224 +declare class HTMLOptionElement extends HTMLElement {
1225 + tagName: 'OPTION';
1226 + defaultSelected: boolean;
1227 + disabled: boolean;
1228 + form: HTMLFormElement | null;
1229 + index: number;
1230 + label: string;
1231 + selected: boolean;
1232 + text: string;
1233 + value: string;
1234 +}
1235 +
1236 +declare class HTMLOptGroupElement extends HTMLElement {
1237 + tagName: 'OPTGROUP';
1238 + disabled: boolean;
1239 + label: string;
1240 +}
1241 +
1242 +declare class HTMLAnchorElement extends HTMLElement {
1243 + tagName: 'A';
1244 + charset: string;
1245 + coords: string;
1246 + download: string;
1247 + hash: string;
1248 + host: string;
1249 + hostname: string;
1250 + href: string;
1251 + hreflang: string;
1252 + media: string;
1253 + name: string;
1254 + origin: string;
1255 + password: string;
1256 + pathname: string;
1257 + port: string;
1258 + protocol: string;
1259 + rel: string;
1260 + rev: string;
1261 + search: string;
1262 + shape: string;
1263 + target: string;
1264 + text: string;
1265 + type: string;
1266 + username: string;
1267 +}
1268 +
1269 +// https://w3c.github.io/html/sec-forms.html#the-label-element
1270 +declare class HTMLLabelElement extends HTMLElement {
1271 + tagName: 'LABEL';
1272 + form: HTMLFormElement | null;
1273 + htmlFor: string;
1274 + control: HTMLElement | null;
1275 +}
1276 +
1277 +declare class HTMLLinkElement extends HTMLElement {
1278 + tagName: 'LINK';
1279 + crossOrigin: ?('anonymous' | 'use-credentials');
1280 + href: string;
1281 + hreflang: string;
1282 + media: string;
1283 + rel: string;
1284 + sizes: DOMTokenList;
1285 + type: string;
1286 + as: string;
1287 +}
1288 +
1289 +declare class HTMLScriptElement extends HTMLElement {
1290 + tagName: 'SCRIPT';
1291 + async: boolean;
1292 + charset: string;
1293 + crossOrigin?: string;
1294 + defer: boolean;
1295 + // flowlint unsafe-getters-setters:off
1296 + get src(): string;
1297 + set src(value: string | TrustedScriptURL): void;
1298 + get text(): string;
1299 + set text(value: string | TrustedScript): void;
1300 + // flowlint unsafe-getters-setters:error
1301 + type: string;
1302 +}
1303 +
1304 +declare class HTMLStyleElement extends HTMLElement {
1305 + tagName: 'STYLE';
1306 + disabled: boolean;
1307 + media: string;
1308 + scoped: boolean;
1309 + sheet: ?CSSStyleSheet;
1310 + type: string;
1311 +}
1312 +
1313 +declare class HTMLParagraphElement extends HTMLElement {
1314 + tagName: 'P';
1315 + align: 'left' | 'center' | 'right' | 'justify'; // deprecated in HTML 4.01
1316 +}
1317 +
1318 +declare class HTMLHtmlElement extends HTMLElement {
1319 + tagName: 'HTML';
1320 +}
1321 +
1322 +declare class HTMLBodyElement extends HTMLElement {
1323 + tagName: 'BODY';
1324 +}
1325 +
1326 +declare class HTMLHeadElement extends HTMLElement {
1327 + tagName: 'HEAD';
1328 +}
1329 +
1330 +declare class HTMLDivElement extends HTMLElement {
1331 + tagName: 'DIV';
1332 +}
1333 +
1334 +declare class HTMLSpanElement extends HTMLElement {
1335 + tagName: 'SPAN';
1336 +}
1337 +
1338 +declare class HTMLAppletElement extends HTMLElement {}
1339 +
1340 +declare class HTMLHeadingElement extends HTMLElement {
1341 + tagName: 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6';
1342 +}
1343 +
1344 +declare class HTMLHRElement extends HTMLElement {
1345 + tagName: 'HR';
1346 +}
1347 +
1348 +declare class HTMLBRElement extends HTMLElement {
1349 + tagName: 'BR';
1350 +}
1351 +
1352 +declare class HTMLDListElement extends HTMLElement {
1353 + tagName: 'DL';
1354 +}
1355 +
1356 +declare class HTMLAreaElement extends HTMLElement {
1357 + tagName: 'AREA';
1358 + alt: string;
1359 + coords: string;
1360 + shape: string;
1361 + target: string;
1362 + download: string;
1363 + ping: string;
1364 + rel: string;
1365 + relList: DOMTokenList;
1366 + referrerPolicy: string;
1367 +}
1368 +
1369 +declare class HTMLDataElement extends HTMLElement {
1370 + tagName: 'DATA';
1371 + value: string;
1372 +}
1373 +
1374 +declare class HTMLDataListElement extends HTMLElement {
1375 + tagName: 'DATALIST';
1376 + options: HTMLCollection<HTMLOptionElement>;
1377 +}
1378 +
1379 +declare class HTMLDialogElement extends HTMLElement {
1380 + tagName: 'DIALOG';
1381 + open: boolean;
1382 + returnValue: string;
1383 + show(): void;
1384 + showModal(): void;
1385 + close(returnValue: ?string): void;
1386 +}
1387 +
1388 +declare class HTMLEmbedElement extends HTMLElement {
1389 + tagName: 'EMBED';
1390 + src: string;
1391 + type: string;
1392 + width: string;
1393 + height: string;
1394 + getSVGDocument(): ?Document;
1395 +}
1396 +
1397 +declare class HTMLMapElement extends HTMLElement {
1398 + tagName: 'MAP';
1399 + areas: HTMLCollection<HTMLAreaElement>;
1400 + images: HTMLCollection<HTMLImageElement>;
1401 + name: string;
1402 +}
1403 +
1404 +declare class HTMLMeterElement extends HTMLElement {
1405 + tagName: 'METER';
1406 + high: number;
1407 + low: number;
1408 + max: number;
1409 + min: number;
1410 + optimum: number;
1411 + value: number;
1412 + labels: NodeList<HTMLLabelElement>;
1413 +}
1414 +
1415 +declare class HTMLModElement extends HTMLElement {
1416 + tagName: 'DEL' | 'INS';
1417 + cite: string;
1418 + dateTime: string;
1419 +}
1420 +
1421 +declare class HTMLObjectElement extends HTMLElement {
1422 + tagName: 'OBJECT';
1423 + contentDocument: ?Document;
1424 + contentWindow: ?WindowProxy;
1425 + data: string;
1426 + form: ?HTMLFormElement;
1427 + height: string;
1428 + name: string;
1429 + type: string;
1430 + typeMustMatch: boolean;
1431 + useMap: string;
1432 + validationMessage: string;
1433 + validity: ValidityState;
1434 + width: string;
1435 + willValidate: boolean;
1436 + checkValidity(): boolean;
1437 + getSVGDocument(): ?Document;
1438 + reportValidity(): boolean;
1439 + setCustomValidity(error: string): void;
1440 +}
1441 +
1442 +declare class HTMLOutputElement extends HTMLElement {
1443 + defaultValue: string;
1444 + form: ?HTMLFormElement;
1445 + htmlFor: DOMTokenList;
1446 + labels: NodeList<HTMLLabelElement>;
1447 + name: string;
1448 + type: string;
1449 + validationMessage: string;
1450 + validity: ValidityState;
1451 + value: string;
1452 + willValidate: boolean;
1453 + checkValidity(): boolean;
1454 + reportValidity(): boolean;
1455 + setCustomValidity(error: string): void;
1456 +}
1457 +
1458 +declare class HTMLParamElement extends HTMLElement {
1459 + tagName: 'PARAM';
1460 + name: string;
1461 + value: string;
1462 +}
1463 +
1464 +declare class HTMLProgressElement extends HTMLElement {
1465 + tagName: 'PROGRESS';
1466 + labels: NodeList<HTMLLabelElement>;
1467 + max: number;
1468 + position: number;
1469 + value: number;
1470 +}
1471 +
1472 +declare class HTMLPictureElement extends HTMLElement {
1473 + tagName: 'PICTURE';
1474 +}
1475 +
1476 +declare class HTMLTimeElement extends HTMLElement {
1477 + tagName: 'TIME';
1478 + dateTime: string;
1479 +}
1480 +
1481 +declare class HTMLTitleElement extends HTMLElement {
1482 + tagName: 'TITLE';
1483 + text: string;
1484 +}
1485 +
1486 +declare class HTMLTrackElement extends HTMLElement {
1487 + tagName: 'TRACK';
1488 + static NONE: 0;
1489 + static LOADING: 1;
1490 + static LOADED: 2;
1491 + static ERROR: 3;
1492 +
1493 + default: boolean;
1494 + kind: string;
1495 + label: string;
1496 + readyState: 0 | 1 | 2 | 3;
1497 + src: string;
1498 + srclang: string;
1499 + track: TextTrack;
1500 +}
1501 +
1502 +declare class HTMLQuoteElement extends HTMLElement {
1503 + tagName: 'BLOCKQUOTE' | 'Q';
1504 + cite: string;
1505 +}
1506 +
1507 +declare class HTMLOListElement extends HTMLElement {
1508 + tagName: 'OL';
1509 + reversed: boolean;
1510 + start: number;
1511 + type: string;
1512 +}
1513 +
1514 +declare class HTMLUListElement extends HTMLElement {
1515 + tagName: 'UL';
1516 +}
1517 +
1518 +declare class HTMLLIElement extends HTMLElement {
1519 + tagName: 'LI';
1520 + value: number;
1521 +}
1522 +
1523 +declare class HTMLPreElement extends HTMLElement {
1524 + tagName: 'PRE';
1525 +}
1526 +
1527 +declare class HTMLMetaElement extends HTMLElement {
1528 + tagName: 'META';
1529 + content: string;
1530 + httpEquiv: string;
1531 + name: string;
1532 +}
1533 +
1534 +declare class HTMLUnknownElement extends HTMLElement {}
1535 +
1536 +declare class Storage {
1537 + length: number;
1538 + getItem(key: string): ?string;
1539 + setItem(key: string, data: string): void;
1540 + clear(): void;
1541 + removeItem(key: string): void;
1542 + key(index: number): ?string;
1543 + [name: string]: ?string;
1544 +}
1545 +
1546 +/* window */
1547 +
1548 +declare type WindowProxy = any;
1549 +declare function alert(message?: any): void;
1550 +declare function prompt(message?: any, value?: any): string;
1551 +declare function close(): void;
1552 +declare function confirm(message?: string): boolean;
1553 +declare function getComputedStyle(
1554 + elt: Element,
1555 + pseudoElt?: string
1556 +): CSSStyleDeclaration;
1557 +declare opaque type AnimationFrameID;
1558 +declare function requestAnimationFrame(
1559 + callback: (timestamp: number) => void
1560 +): AnimationFrameID;
1561 +declare function cancelAnimationFrame(requestId: AnimationFrameID): void;
1562 +declare opaque type IdleCallbackID;
1563 +declare function requestIdleCallback(
1564 + cb: (deadline: {
1565 + didTimeout: boolean,
1566 + timeRemaining: () => number,
1567 + ...
1568 + }) => void,
1569 + opts?: {timeout: number, ...}
1570 +): IdleCallbackID;
1571 +declare function cancelIdleCallback(id: IdleCallbackID): void;
1572 +declare var localStorage: Storage;
1573 +declare var devicePixelRatio: number;
1574 +declare function focus(): void;
1575 +declare function onfocus(ev: Event): any;
1576 +declare function open(
1577 + url?: string,
1578 + target?: string,
1579 + features?: string,
1580 + replace?: boolean
1581 +): any;
1582 +declare var parent: WindowProxy;
1583 +declare function print(): void;
1584 +declare var self: any;
1585 +declare var sessionStorage: Storage;
1586 +declare var top: WindowProxy;
1587 +declare function getSelection(): Selection | null;
1588 +declare var customElements: CustomElementRegistry;
1589 +declare function scroll(x: number, y: number): void;
1590 +declare function scroll(options: ScrollToOptions): void;
1591 +declare function scrollTo(x: number, y: number): void;
1592 +declare function scrollTo(options: ScrollToOptions): void;
1593 +declare function scrollBy(x: number, y: number): void;
1594 +declare function scrollBy(options: ScrollToOptions): void;
1595 +
1596 +type HTMLElementTagNameMap = {
1597 + a: HTMLAnchorElement,
1598 + abbr: HTMLElement,
1599 + address: HTMLElement,
1600 + area: HTMLAreaElement,
1601 + article: HTMLElement,
1602 + aside: HTMLElement,
1603 + audio: HTMLAudioElement,
1604 + b: HTMLElement,
1605 + base: HTMLBaseElement,
1606 + bdi: HTMLElement,
1607 + bdo: HTMLElement,
1608 + blockquote: HTMLQuoteElement,
1609 + body: HTMLBodyElement,
1610 + br: HTMLBRElement,
1611 + button: HTMLButtonElement,
1612 + canvas: HTMLCanvasElement,
1613 + caption: HTMLTableCaptionElement,
1614 + cite: HTMLElement,
1615 + code: HTMLElement,
1616 + col: HTMLTableColElement,
1617 + colgroup: HTMLTableColElement,
1618 + data: HTMLDataElement,
1619 + datalist: HTMLDataListElement,
1620 + dd: HTMLElement,
1621 + del: HTMLModElement,
1622 + details: HTMLDetailsElement,
1623 + dfn: HTMLElement,
1624 + dialog: HTMLDialogElement,
1625 + div: HTMLDivElement,
1626 + dl: HTMLDListElement,
1627 + dt: HTMLElement,
1628 + em: HTMLElement,
1629 + embed: HTMLEmbedElement,
1630 + fieldset: HTMLFieldSetElement,
1631 + figcaption: HTMLElement,
1632 + figure: HTMLElement,
1633 + footer: HTMLElement,
1634 + form: HTMLFormElement,
1635 + h1: HTMLHeadingElement,
1636 + h2: HTMLHeadingElement,
1637 + h3: HTMLHeadingElement,
1638 + h4: HTMLHeadingElement,
1639 + h5: HTMLHeadingElement,
1640 + h6: HTMLHeadingElement,
1641 + head: HTMLHeadElement,
1642 + header: HTMLElement,
1643 + hgroup: HTMLElement,
1644 + hr: HTMLHRElement,
1645 + html: HTMLHtmlElement,
1646 + i: HTMLElement,
1647 + iframe: HTMLIFrameElement,
1648 + img: HTMLImageElement,
1649 + input: HTMLInputElement,
1650 + ins: HTMLModElement,
1651 + kbd: HTMLElement,
1652 + label: HTMLLabelElement,
1653 + legend: HTMLLegendElement,
1654 + li: HTMLLIElement,
1655 + link: HTMLLinkElement,
1656 + main: HTMLElement,
1657 + map: HTMLMapElement,
1658 + mark: HTMLElement,
1659 + menu: HTMLMenuElement,
1660 + meta: HTMLMetaElement,
1661 + meter: HTMLMeterElement,
1662 + nav: HTMLElement,
1663 + noscript: HTMLElement,
1664 + object: HTMLObjectElement,
1665 + ol: HTMLOListElement,
1666 + optgroup: HTMLOptGroupElement,
1667 + option: HTMLOptionElement,
1668 + output: HTMLOutputElement,
1669 + p: HTMLParagraphElement,
1670 + picture: HTMLPictureElement,
1671 + pre: HTMLPreElement,
1672 + progress: HTMLProgressElement,
1673 + q: HTMLQuoteElement,
1674 + rp: HTMLElement,
1675 + rt: HTMLElement,
1676 + ruby: HTMLElement,
1677 + s: HTMLElement,
1678 + samp: HTMLElement,
1679 + script: HTMLScriptElement,
1680 + search: HTMLElement,
1681 + section: HTMLElement,
1682 + select: HTMLSelectElement,
1683 + slot: HTMLSlotElement,
1684 + small: HTMLElement,
1685 + source: HTMLSourceElement,
1686 + span: HTMLSpanElement,
1687 + strong: HTMLElement,
1688 + style: HTMLStyleElement,
1689 + sub: HTMLElement,
1690 + summary: HTMLElement,
1691 + sup: HTMLElement,
1692 + table: HTMLTableElement,
1693 + tbody: HTMLTableSectionElement,
1694 + td: HTMLTableCellElement,
1695 + template: HTMLTemplateElement,
1696 + textarea: HTMLTextAreaElement,
1697 + tfoot: HTMLTableSectionElement,
1698 + th: HTMLTableCellElement,
1699 + thead: HTMLTableSectionElement,
1700 + time: HTMLTimeElement,
1701 + title: HTMLTitleElement,
1702 + tr: HTMLTableRowElement,
1703 + track: HTMLTrackElement,
1704 + u: HTMLElement,
1705 + ul: HTMLUListElement,
1706 + var: HTMLElement,
1707 + video: HTMLVideoElement,
1708 + wbr: HTMLElement,
1709 + [string]: Element,
1710 +};
flow-typed/environments/node.js new
+4282
@@ -0,0 +1,4282 @@
1 +// flow-typed signature: 44d8f5b0b708cdf7288ec50b7c08e1bf
2 +// flow-typed version: 832153ff79/node/flow_>=v0.261.x
3 +
4 +interface ErrnoError extends Error {
5 + address?: string;
6 + code?: string;
7 + dest?: string;
8 + errno?: string | number;
9 + info?: Object;
10 + path?: string;
11 + port?: number;
12 + syscall?: string;
13 +}
14 +
15 +type Node$Conditional<T: boolean, IfTrue, IfFalse> = T extends true
16 + ? IfTrue
17 + : T extends false
18 + ? IfFalse
19 + : IfTrue | IfFalse;
20 +
21 +type buffer$NonBufferEncoding =
22 + | 'hex'
23 + | 'HEX'
24 + | 'utf8'
25 + | 'UTF8'
26 + | 'utf-8'
27 + | 'UTF-8'
28 + | 'ascii'
29 + | 'ASCII'
30 + | 'binary'
31 + | 'BINARY'
32 + | 'base64'
33 + | 'BASE64'
34 + | 'ucs2'
35 + | 'UCS2'
36 + | 'ucs-2'
37 + | 'UCS-2'
38 + | 'utf16le'
39 + | 'UTF16LE'
40 + | 'utf-16le'
41 + | 'UTF-16LE'
42 + | 'latin1';
43 +type buffer$Encoding = buffer$NonBufferEncoding | 'buffer';
44 +type buffer$ToJSONRet = {
45 + type: string,
46 + data: Array<number>,
47 + ...
48 +};
49 +
50 +declare class Buffer extends Uint8Array {
51 + constructor(
52 + value: Array<number> | number | string | Buffer | ArrayBuffer,
53 + encoding?: buffer$Encoding
54 + ): void;
55 + [i: number]: number;
56 + length: number;
57 +
58 + compare(otherBuffer: Buffer): number;
59 + copy(
60 + targetBuffer: Buffer,
61 + targetStart?: number,
62 + sourceStart?: number,
63 + sourceEnd?: number
64 + ): number;
65 + entries(): Iterator<[number, number]>;
66 + equals(otherBuffer: Buffer): boolean;
67 + fill(
68 + value: string | Buffer | number,
69 + offset?: number,
70 + end?: number,
71 + encoding?: string
72 + ): this;
73 + fill(value: string, encoding?: string): this;
74 + includes(
75 + value: string | Buffer | number,
76 + offsetOrEncoding?: number | buffer$Encoding,
77 + encoding?: buffer$Encoding
78 + ): boolean;
79 + indexOf(
80 + value: string | Buffer | number,
81 + offsetOrEncoding?: number | buffer$Encoding,
82 + encoding?: buffer$Encoding
83 + ): number;
84 + inspect(): string;
85 + keys(): Iterator<number>;
86 + lastIndexOf(
87 + value: string | Buffer | number,
88 + offsetOrEncoding?: number | buffer$Encoding,
89 + encoding?: buffer$Encoding
90 + ): number;
91 + readDoubleBE(offset?: number, noAssert?: boolean): number;
92 + readDoubleLE(offset?: number, noAssert?: boolean): number;
93 + readFloatBE(offset?: number, noAssert?: boolean): number;
94 + readFloatLE(offset?: number, noAssert?: boolean): number;
95 + readInt16BE(offset?: number, noAssert?: boolean): number;
96 + readInt16LE(offset?: number, noAssert?: boolean): number;
97 + readInt32BE(offset?: number, noAssert?: boolean): number;
98 + readInt32LE(offset?: number, noAssert?: boolean): number;
99 + readInt8(offset?: number, noAssert?: boolean): number;
100 + readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
101 + readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
102 + readUInt16BE(offset?: number, noAssert?: boolean): number;
103 + readUInt16LE(offset?: number, noAssert?: boolean): number;
104 + readUInt32BE(offset?: number, noAssert?: boolean): number;
105 + readUInt32LE(offset?: number, noAssert?: boolean): number;
106 + readUInt8(offset?: number, noAssert?: boolean): number;
107 + readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
108 + readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
109 + slice(start?: number, end?: number): this;
110 + swap16(): Buffer;
111 + swap32(): Buffer;
112 + swap64(): Buffer;
113 + toJSON(): buffer$ToJSONRet;
114 + toString(encoding?: buffer$Encoding, start?: number, end?: number): string;
115 + values(): Iterator<number>;
116 + write(
117 + string: string,
118 + offset?: number,
119 + length?: number,
120 + encoding?: buffer$Encoding
121 + ): number;
122 + writeDoubleBE(value: number, offset?: number, noAssert?: boolean): number;
123 + writeDoubleLE(value: number, offset?: number, noAssert?: boolean): number;
124 + writeFloatBE(value: number, offset?: number, noAssert?: boolean): number;
125 + writeFloatLE(value: number, offset?: number, noAssert?: boolean): number;
126 + writeInt16BE(value: number, offset?: number, noAssert?: boolean): number;
127 + writeInt16LE(value: number, offset?: number, noAssert?: boolean): number;
128 + writeInt32BE(value: number, offset?: number, noAssert?: boolean): number;
129 + writeInt32LE(value: number, offset?: number, noAssert?: boolean): number;
130 + writeInt8(value: number, offset?: number, noAssert?: boolean): number;
131 + writeIntBE(
132 + value: number,
133 + offset: number,
134 + byteLength: number,
135 + noAssert?: boolean
136 + ): number;
137 + writeIntLE(
138 + value: number,
139 + offset: number,
140 + byteLength: number,
141 + noAssert?: boolean
142 + ): number;
143 + writeUInt16BE(value: number, offset?: number, noAssert?: boolean): number;
144 + writeUInt16LE(value: number, offset?: number, noAssert?: boolean): number;
145 + writeUInt32BE(value: number, offset?: number, noAssert?: boolean): number;
146 + writeUInt32LE(value: number, offset?: number, noAssert?: boolean): number;
147 + writeUInt8(value: number, offset?: number, noAssert?: boolean): number;
148 + writeUIntBE(
149 + value: number,
150 + offset: number,
151 + byteLength: number,
152 + noAssert?: boolean
153 + ): number;
154 + writeUIntLE(
155 + value: number,
156 + offset: number,
157 + byteLength: number,
158 + noAssert?: boolean
159 + ): number;
160 +
161 + static alloc(
162 + size: number,
163 + fill?: string | number,
164 + encoding?: buffer$Encoding
165 + ): Buffer;
166 + static allocUnsafe(size: number): Buffer;
167 + static allocUnsafeSlow(size: number): Buffer;
168 + static byteLength(
169 + string: string | Buffer | $TypedArray | DataView | ArrayBuffer,
170 + encoding?: buffer$Encoding
171 + ): number;
172 + static compare(buf1: Buffer, buf2: Buffer): number;
173 + static concat(list: Array<Buffer>, totalLength?: number): Buffer;
174 +
175 + static from(value: Buffer): Buffer;
176 + static from(value: string, encoding?: buffer$Encoding): Buffer;
177 + static from(
178 + value: ArrayBuffer | SharedArrayBuffer,
179 + byteOffset?: number,
180 + length?: number
181 + ): Buffer;
182 + static from(value: Iterable<number>): this;
183 + static isBuffer(obj: any): boolean;
184 + static isEncoding(encoding: string): boolean;
185 +}
186 +
187 +declare type Node$Buffer = typeof Buffer;
188 +
189 +declare module 'buffer' {
190 + declare var kMaxLength: number;
191 + declare var INSPECT_MAX_BYTES: number;
192 + declare function transcode(
193 + source: Node$Buffer,
194 + fromEnc: buffer$Encoding,
195 + toEnc: buffer$Encoding
196 + ): Node$Buffer;
197 + declare var Buffer: Node$Buffer;
198 +}
199 +
200 +type child_process$execOpts = {
201 + cwd?: string,
202 + env?: Object,
203 + encoding?: string,
204 + shell?: string,
205 + timeout?: number,
206 + maxBuffer?: number,
207 + killSignal?: string | number,
208 + uid?: number,
209 + gid?: number,
210 + windowsHide?: boolean,
211 + ...
212 +};
213 +
214 +declare class child_process$Error extends Error {
215 + code: number | string | null;
216 + errno?: string;
217 + syscall?: string;
218 + path?: string;
219 + spawnargs?: Array<string>;
220 + killed?: boolean;
221 + signal?: string | null;
222 + cmd: string;
223 +}
224 +
225 +type child_process$execCallback = (
226 + error: ?child_process$Error,
227 + stdout: string | Buffer,
228 + stderr: string | Buffer
229 +) => void;
230 +
231 +type child_process$execSyncOpts = {
232 + cwd?: string,
233 + input?: string | Buffer | $TypedArray | DataView,
234 + stdio?: string | Array<any>,
235 + env?: Object,
236 + shell?: string,
237 + uid?: number,
238 + gid?: number,
239 + timeout?: number,
240 + killSignal?: string | number,
241 + maxBuffer?: number,
242 + encoding?: string,
243 + windowsHide?: boolean,
244 + ...
245 +};
246 +
247 +type child_process$execFileOpts = {
248 + cwd?: string,
249 + env?: Object,
250 + encoding?: string,
251 + timeout?: number,
252 + maxBuffer?: number,
253 + killSignal?: string | number,
254 + uid?: number,
255 + gid?: number,
256 + windowsHide?: boolean,
257 + windowsVerbatimArguments?: boolean,
258 + shell?: boolean | string,
259 + ...
260 +};
261 +
262 +type child_process$execFileCallback = (
263 + error: ?child_process$Error,
264 + stdout: string | Buffer,
265 + stderr: string | Buffer
266 +) => void;
267 +
268 +type child_process$execFileSyncOpts = {
269 + cwd?: string,
270 + input?: string | Buffer | $TypedArray | DataView,
271 + stdio?: string | Array<any>,
272 + env?: Object,
273 + uid?: number,
274 + gid?: number,
275 + timeout?: number,
276 + killSignal?: string | number,
277 + maxBuffer?: number,
278 + encoding?: string,
279 + windowsHide?: boolean,
280 + shell?: boolean | string,
281 + ...
282 +};
283 +
284 +type child_process$forkOpts = {
285 + cwd?: string,
286 + env?: Object,
287 + execPath?: string,
288 + execArgv?: Array<string>,
289 + silent?: boolean,
290 + stdio?: Array<any> | string,
291 + windowsVerbatimArguments?: boolean,
292 + uid?: number,
293 + gid?: number,
294 + ...
295 +};
296 +
297 +type child_process$Handle = any; // TODO
298 +
299 +type child_process$spawnOpts = {
300 + cwd?: string,
301 + env?: Object,
302 + argv0?: string,
303 + stdio?: string | Array<any>,
304 + detached?: boolean,
305 + uid?: number,
306 + gid?: number,
307 + shell?: boolean | string,
308 + windowsVerbatimArguments?: boolean,
309 + windowsHide?: boolean,
310 + ...
311 +};
312 +
313 +type child_process$spawnRet = {
314 + pid: number,
315 + output: Array<any>,
316 + stdout: Buffer | string,
317 + stderr: Buffer | string,
318 + status: number,
319 + signal: string,
320 + error: Error,
321 + ...
322 +};
323 +
324 +type child_process$spawnSyncOpts = {
325 + cwd?: string,
326 + input?: string | Buffer,
327 + stdio?: string | Array<any>,
328 + env?: Object,
329 + uid?: number,
330 + gid?: number,
331 + timeout?: number,
332 + killSignal?: string,
333 + maxBuffer?: number,
334 + encoding?: string,
335 + shell?: boolean | string,
336 + ...
337 +};
338 +
339 +type child_process$spawnSyncRet = child_process$spawnRet;
340 +
341 +declare class child_process$ChildProcess extends events$EventEmitter {
342 + channel: Object;
343 + connected: boolean;
344 + killed: boolean;
345 + pid: number;
346 + exitCode: number | null;
347 + stderr: stream$Readable;
348 + stdin: stream$Writable;
349 + stdio: Array<any>;
350 + stdout: stream$Readable;
351 +
352 + disconnect(): void;
353 + kill(signal?: string): void;
354 + send(
355 + message: Object,
356 + sendHandleOrCallback?: child_process$Handle,
357 + optionsOrCallback?: Object | Function,
358 + callback?: Function
359 + ): boolean;
360 + unref(): void;
361 + ref(): void;
362 +}
363 +
364 +declare module 'child_process' {
365 + declare var ChildProcess: typeof child_process$ChildProcess;
366 +
367 + declare function exec(
368 + command: string,
369 + optionsOrCallback?: child_process$execOpts | child_process$execCallback,
370 + callback?: child_process$execCallback
371 + ): child_process$ChildProcess;
372 +
373 + declare function execSync(
374 + command: string,
375 + options: {
376 + encoding: buffer$NonBufferEncoding,
377 + ...
378 + } & child_process$execSyncOpts
379 + ): string;
380 +
381 + declare function execSync(
382 + command: string,
383 + options?: child_process$execSyncOpts
384 + ): Buffer;
385 +
386 + declare function execFile(
387 + file: string,
388 + argsOrOptionsOrCallback?:
389 + | Array<string>
390 + | child_process$execFileOpts
391 + | child_process$execFileCallback,
392 + optionsOrCallback?:
393 + | child_process$execFileOpts
394 + | child_process$execFileCallback,
395 + callback?: child_process$execFileCallback
396 + ): child_process$ChildProcess;
397 +
398 + declare function execFileSync(
399 + command: string,
400 + argsOrOptions?: Array<string> | child_process$execFileSyncOpts,
401 + options?: child_process$execFileSyncOpts
402 + ): Buffer | string;
403 +
404 + declare function fork(
405 + modulePath: string,
406 + argsOrOptions?: Array<string> | child_process$forkOpts,
407 + options?: child_process$forkOpts
408 + ): child_process$ChildProcess;
409 +
410 + declare function spawn(
411 + command: string,
412 + argsOrOptions?: Array<string> | child_process$spawnOpts,
413 + options?: child_process$spawnOpts
414 + ): child_process$ChildProcess;
415 +
416 + declare function spawnSync(
417 + command: string,
418 + argsOrOptions?: Array<string> | child_process$spawnSyncOpts,
419 + options?: child_process$spawnSyncOpts
420 + ): child_process$spawnSyncRet;
421 +}
422 +
423 +declare module 'cluster' {
424 + declare type ClusterSettings = {
425 + execArgv: Array<string>,
426 + exec: string,
427 + args: Array<string>,
428 + cwd: string,
429 + serialization: 'json' | 'advanced',
430 + silent: boolean,
431 + stdio: Array<any>,
432 + uid: number,
433 + gid: number,
434 + inspectPort: number | (() => number),
435 + windowsHide: boolean,
436 + ...
437 + };
438 +
439 + declare type ClusterSettingsOpt = {
440 + execArgv?: Array<string>,
441 + exec?: string,
442 + args?: Array<string>,
443 + cwd?: string,
444 + serialization?: 'json' | 'advanced',
445 + silent?: boolean,
446 + stdio?: Array<any>,
447 + uid?: number,
448 + gid?: number,
449 + inspectPort?: number | (() => number),
450 + windowsHide?: boolean,
451 + ...
452 + };
453 +
454 + declare class Worker extends events$EventEmitter {
455 + id: number;
456 + process: child_process$ChildProcess;
457 + suicide: boolean;
458 +
459 + disconnect(): void;
460 + isConnected(): boolean;
461 + isDead(): boolean;
462 + kill(signal?: string): void;
463 + send(
464 + message: Object,
465 + sendHandleOrCallback?: child_process$Handle | Function,
466 + callback?: Function
467 + ): boolean;
468 + }
469 +
470 + declare class Cluster extends events$EventEmitter {
471 + isMaster: boolean;
472 + isWorker: boolean;
473 + settings: ClusterSettings;
474 + worker: Worker;
475 + workers: {[id: number]: Worker};
476 +
477 + disconnect(callback?: () => void): void;
478 + fork(env?: Object): Worker;
479 + setupMaster(settings?: ClusterSettingsOpt): void;
480 + }
481 +
482 + declare module.exports: Cluster;
483 +}
484 +
485 +type crypto$createCredentialsDetails = any; // TODO
486 +
487 +declare class crypto$Cipher extends stream$Duplex {
488 + final(output_encoding: 'latin1' | 'binary' | 'base64' | 'hex'): string;
489 + final(output_encoding: void): Buffer;
490 + getAuthTag(): Buffer;
491 + setAAD(buffer: Buffer): crypto$Cipher;
492 + setAuthTag(buffer: Buffer): void;
493 + setAutoPadding(auto_padding?: boolean): crypto$Cipher;
494 + update(
495 + data: string,
496 + input_encoding: 'utf8' | 'ascii' | 'latin1' | 'binary',
497 + output_encoding: 'latin1' | 'binary' | 'base64' | 'hex'
498 + ): string;
499 + update(
500 + data: string,
501 + input_encoding: 'utf8' | 'ascii' | 'latin1' | 'binary',
502 + output_encoding: void
503 + ): Buffer;
504 + update(
505 + data: Buffer,
506 + input_encoding: void | 'utf8' | 'ascii' | 'latin1' | 'binary',
507 + output_encoding: 'latin1' | 'binary' | 'base64' | 'hex'
508 + ): string;
509 + update(data: Buffer, input_encoding: void, output_encoding: void): Buffer;
510 +}
511 +
512 +type crypto$Credentials = {...};
513 +
514 +type crypto$DiffieHellman = {
515 + computeSecret(
516 + other_public_key: string,
517 + input_encoding?: string,
518 + output_encoding?: string
519 + ): any,
520 + generateKeys(encoding?: string): any,
521 + getGenerator(encoding?: string): any,
522 + getPrime(encoding?: string): any,
523 + getPrivateKey(encoding?: string): any,
524 + getPublicKey(encoding?: string): any,
525 + setPrivateKey(private_key: any, encoding?: string): void,
526 + setPublicKey(public_key: any, encoding?: string): void,
527 + ...
528 +};
529 +
530 +type crypto$ECDH$Encoding = 'latin1' | 'hex' | 'base64';
531 +type crypto$ECDH$Format = 'compressed' | 'uncompressed';
532 +
533 +declare class crypto$ECDH {
534 + computeSecret(other_public_key: Buffer | $TypedArray | DataView): Buffer;
535 + computeSecret(
536 + other_public_key: string,
537 + input_encoding: crypto$ECDH$Encoding
538 + ): Buffer;
539 + computeSecret(
540 + other_public_key: Buffer | $TypedArray | DataView,
541 + output_encoding: crypto$ECDH$Encoding
542 + ): string;
543 + computeSecret(
544 + other_public_key: string,
545 + input_encoding: crypto$ECDH$Encoding,
546 + output_encoding: crypto$ECDH$Encoding
547 + ): string;
548 + generateKeys(format?: crypto$ECDH$Format): Buffer;
549 + generateKeys(
550 + encoding: crypto$ECDH$Encoding,
551 + format?: crypto$ECDH$Format
552 + ): string;
553 + getPrivateKey(): Buffer;
554 + getPrivateKey(encoding: crypto$ECDH$Encoding): string;
555 + getPublicKey(format?: crypto$ECDH$Format): Buffer;
556 + getPublicKey(
557 + encoding: crypto$ECDH$Encoding,
558 + format?: crypto$ECDH$Format
559 + ): string;
560 + setPrivateKey(private_key: Buffer | $TypedArray | DataView): void;
561 + setPrivateKey(private_key: string, encoding: crypto$ECDH$Encoding): void;
562 +}
563 +
564 +declare class crypto$Decipher extends stream$Duplex {
565 + final(output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8'): string;
566 + final(output_encoding: void): Buffer;
567 + getAuthTag(): Buffer;
568 + setAAD(buffer: Buffer): void;
569 + setAuthTag(buffer: Buffer): void;
570 + setAutoPadding(auto_padding?: boolean): crypto$Cipher;
571 + update(
572 + data: string,
573 + input_encoding: 'latin1' | 'binary' | 'base64' | 'hex',
574 + output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8'
575 + ): string;
576 + update(
577 + data: string,
578 + input_encoding: 'latin1' | 'binary' | 'base64' | 'hex',
579 + output_encoding: void
580 + ): Buffer;
581 + update(
582 + data: Buffer,
583 + input_encoding: void,
584 + output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8'
585 + ): string;
586 + update(data: Buffer, input_encoding: void, output_encoding: void): Buffer;
587 +}
588 +
589 +declare class crypto$Hash extends stream$Duplex {
590 + digest(encoding: 'hex' | 'latin1' | 'binary' | 'base64'): string;
591 + digest(encoding: 'buffer'): Buffer;
592 + digest(encoding: void): Buffer;
593 + update(
594 + data: string | Buffer,
595 + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary'
596 + ): crypto$Hash;
597 +}
598 +
599 +declare class crypto$Hmac extends stream$Duplex {
600 + digest(encoding: 'hex' | 'latin1' | 'binary' | 'base64'): string;
601 + digest(encoding: 'buffer'): Buffer;
602 + digest(encoding: void): Buffer;
603 + update(
604 + data: string | Buffer,
605 + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary'
606 + ): crypto$Hmac;
607 +}
608 +
609 +type crypto$Sign$private_key =
610 + | string
611 + | {
612 + key: string,
613 + passphrase: string,
614 + ...
615 + };
616 +declare class crypto$Sign extends stream$Writable {
617 + static (algorithm: string, options?: writableStreamOptions): crypto$Sign;
618 + constructor(algorithm: string, options?: writableStreamOptions): void;
619 + sign(
620 + private_key: crypto$Sign$private_key,
621 + output_format: 'latin1' | 'binary' | 'hex' | 'base64'
622 + ): string;
623 + sign(private_key: crypto$Sign$private_key, output_format: void): Buffer;
624 + update(
625 + data: string | Buffer,
626 + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary'
627 + ): crypto$Sign;
628 +}
629 +
630 +declare class crypto$Verify extends stream$Writable {
631 + static (algorithm: string, options?: writableStreamOptions): crypto$Verify;
632 + constructor(algorithm: string, options?: writableStreamOptions): void;
633 + update(
634 + data: string | Buffer,
635 + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary'
636 + ): crypto$Verify;
637 + verify(
638 + object: string,
639 + signature: string | Buffer | $TypedArray | DataView,
640 + signature_format: 'latin1' | 'binary' | 'hex' | 'base64'
641 + ): boolean;
642 + verify(object: string, signature: Buffer, signature_format: void): boolean;
643 +}
644 +
645 +type crypto$key =
646 + | string
647 + | {
648 + key: string,
649 + passphrase?: string,
650 + // TODO: enum type in crypto.constants
651 + padding?: string,
652 + ...
653 + };
654 +
655 +declare module 'crypto' {
656 + declare var DEFAULT_ENCODING: string;
657 +
658 + declare class Sign extends crypto$Sign {}
659 + declare class Verify extends crypto$Verify {}
660 +
661 + declare function createCipher(
662 + algorithm: string,
663 + password: string | Buffer
664 + ): crypto$Cipher;
665 + declare function createCipheriv(
666 + algorithm: string,
667 + key: string | Buffer,
668 + iv: string | Buffer
669 + ): crypto$Cipher;
670 + declare function createCredentials(
671 + details?: crypto$createCredentialsDetails
672 + ): crypto$Credentials;
673 + declare function createDecipher(
674 + algorithm: string,
675 + password: string | Buffer
676 + ): crypto$Decipher;
677 + declare function createDecipheriv(
678 + algorithm: string,
679 + key: string | Buffer,
680 + iv: string | Buffer
681 + ): crypto$Decipher;
682 + declare function createDiffieHellman(
683 + prime_length: number
684 + ): crypto$DiffieHellman;
685 + declare function createDiffieHellman(
686 + prime: number,
687 + encoding?: string
688 + ): crypto$DiffieHellman;
689 + declare function createECDH(curveName: string): crypto$ECDH;
690 + declare function createHash(algorithm: string): crypto$Hash;
691 + declare function createHmac(
692 + algorithm: string,
693 + key: string | Buffer
694 + ): crypto$Hmac;
695 + declare function createSign(algorithm: string): crypto$Sign;
696 + declare function createVerify(algorithm: string): crypto$Verify;
697 + declare function getCiphers(): Array<string>;
698 + declare function getCurves(): Array<string>;
699 + declare function getDiffieHellman(group_name: string): crypto$DiffieHellman;
700 + declare function getHashes(): Array<string>;
701 + declare function pbkdf2(
702 + password: string | Buffer,
703 + salt: string | Buffer,
704 + iterations: number,
705 + keylen: number,
706 + digest: string,
707 + callback: (err: ?Error, derivedKey: Buffer) => void
708 + ): void;
709 + declare function pbkdf2(
710 + password: string | Buffer,
711 + salt: string | Buffer,
712 + iterations: number,
713 + keylen: number,
714 + callback: (err: ?Error, derivedKey: Buffer) => void
715 + ): void;
716 + declare function pbkdf2Sync(
717 + password: string | Buffer,
718 + salt: string | Buffer,
719 + iterations: number,
720 + keylen: number,
721 + digest?: string
722 + ): Buffer;
723 + declare function scrypt(
724 + password: string | Buffer,
725 + salt: string | Buffer,
726 + keylen: number,
727 + options:
728 + | {|N?: number, r?: number, p?: number, maxmem?: number|}
729 + | {|
730 + cost?: number,
731 + blockSize?: number,
732 + parallelization?: number,
733 + maxmem?: number,
734 + |},
735 + callback: (err: ?Error, derivedKey: Buffer) => void
736 + ): void;
737 + declare function scrypt(
738 + password: string | Buffer,
739 + salt: string | Buffer,
740 + keylen: number,
741 + callback: (err: ?Error, derivedKey: Buffer) => void
742 + ): void;
743 + declare function scryptSync(
744 + password: string | Buffer,
745 + salt: string | Buffer,
746 + keylen: number,
747 + options?:
748 + | {|N?: number, r?: number, p?: number, maxmem?: number|}
749 + | {|
750 + cost?: number,
751 + blockSize?: number,
752 + parallelization?: number,
753 + maxmem?: number,
754 + |}
755 + ): Buffer;
756 + declare function privateDecrypt(
757 + private_key: crypto$key,
758 + buffer: Buffer
759 + ): Buffer;
760 + declare function privateEncrypt(
761 + private_key: crypto$key,
762 + buffer: Buffer
763 + ): Buffer;
764 + declare function publicDecrypt(key: crypto$key, buffer: Buffer): Buffer;
765 + declare function publicEncrypt(key: crypto$key, buffer: Buffer): Buffer;
766 + // `UNUSED` argument strictly enforces arity to enable overloading this
767 + // function with 1-arg and 2-arg variants.
768 + declare function pseudoRandomBytes(size: number, UNUSED: void): Buffer;
769 + declare function pseudoRandomBytes(
770 + size: number,
771 + callback: (err: ?Error, buffer: Buffer) => void
772 + ): void;
773 + // `UNUSED` argument strictly enforces arity to enable overloading this
774 + // function with 1-arg and 2-arg variants.
775 + declare function randomBytes(size: number, UNUSED: void): Buffer;
776 + declare function randomBytes(
777 + size: number,
778 + callback: (err: ?Error, buffer: Buffer) => void
779 + ): void;
780 + declare function randomFillSync(
781 + buffer: Buffer | $TypedArray | DataView
782 + ): void;
783 + declare function randomFillSync(
784 + buffer: Buffer | $TypedArray | DataView,
785 + offset: number
786 + ): void;
787 + declare function randomFillSync(
788 + buffer: Buffer | $TypedArray | DataView,
789 + offset: number,
790 + size: number
791 + ): void;
792 + declare function randomFill(
793 + buffer: Buffer | $TypedArray | DataView,
794 + callback: (err: ?Error, buffer: Buffer) => void
795 + ): void;
796 + declare function randomFill(
797 + buffer: Buffer | $TypedArray | DataView,
798 + offset: number,
799 + callback: (err: ?Error, buffer: Buffer) => void
800 + ): void;
801 + declare function randomFill(
802 + buffer: Buffer | $TypedArray | DataView,
803 + offset: number,
804 + size: number,
805 + callback: (err: ?Error, buffer: Buffer) => void
806 + ): void;
807 + declare function randomUUID(
808 + options?: $ReadOnly<{|disableEntropyCache?: boolean|}>
809 + ): string;
810 + declare function timingSafeEqual(
811 + a: Buffer | $TypedArray | DataView,
812 + b: Buffer | $TypedArray | DataView
813 + ): boolean;
814 +}
815 +
816 +type net$Socket$address = {
817 + address: string,
818 + family: string,
819 + port: number,
820 + ...
821 +};
822 +type dgram$Socket$rinfo = {
823 + address: string,
824 + family: 'IPv4' | 'IPv6',
825 + port: number,
826 + size: number,
827 + ...
828 +};
829 +
830 +declare class dgram$Socket extends events$EventEmitter {
831 + addMembership(multicastAddress: string, multicastInterface?: string): void;
832 + address(): net$Socket$address;
833 + bind(port?: number, address?: string, callback?: () => void): void;
834 + close(callback?: () => void): void;
835 + dropMembership(multicastAddress: string, multicastInterface?: string): void;
836 + ref(): void;
837 + send(
838 + msg: Buffer,
839 + port: number,
840 + address: string,
841 + callback?: (err: ?Error, bytes: any) => mixed
842 + ): void;
843 + send(
844 + msg: Buffer,
845 + offset: number,
846 + length: number,
847 + port: number,
848 + address: string,
849 + callback?: (err: ?Error, bytes: any) => mixed
850 + ): void;
851 + setBroadcast(flag: boolean): void;
852 + setMulticastLoopback(flag: boolean): void;
853 + setMulticastTTL(ttl: number): void;
854 + setTTL(ttl: number): void;
855 + unref(): void;
856 +}
857 +
858 +declare module 'dgram' {
859 + declare function createSocket(
860 + options: string | {type: string, ...},
861 + callback?: () => void
862 + ): dgram$Socket;
863 +}
864 +
865 +declare module 'dns' {
866 + declare var ADDRGETNETWORKPARAMS: string;
867 + declare var BADFAMILY: string;
868 + declare var BADFLAGS: string;
869 + declare var BADHINTS: string;
870 + declare var BADQUERY: string;
871 + declare var BADNAME: string;
872 + declare var BADRESP: string;
873 + declare var BADSTR: string;
874 + declare var CANCELLED: string;
875 + declare var CONNREFUSED: string;
876 + declare var DESTRUCTION: string;
877 + declare var EOF: string;
878 + declare var FILE: string;
879 + declare var FORMER: string;
880 + declare var LOADIPHLPAPI: string;
881 + declare var NODATA: string;
882 + declare var NOMEM: string;
883 + declare var NONAME: string;
884 + declare var NOTFOUND: string;
885 + declare var NOTIMP: string;
886 + declare var NOTINITIALIZED: string;
887 + declare var REFUSED: string;
888 + declare var SERVFAIL: string;
889 + declare var TIMEOUT: string;
890 + declare var ADDRCONFIG: number;
891 + declare var V4MAPPED: number;
892 +
893 + declare type LookupOptions = {
894 + family?: number,
895 + hints?: number,
896 + verbatim?: boolean,
897 + all?: boolean,
898 + ...
899 + };
900 +
901 + declare function lookup(
902 + domain: string,
903 + options: number | LookupOptions,
904 + callback: (err: ?Error, address: string, family: number) => void
905 + ): void;
906 + declare function lookup(
907 + domain: string,
908 + callback: (err: ?Error, address: string, family: number) => void
909 + ): void;
910 +
911 + declare function resolve(
912 + domain: string,
913 + rrtype?: string,
914 + callback?: (err: ?Error, addresses: Array<any>) => void
915 + ): void;
916 +
917 + declare function resolve4(
918 + domain: string,
919 + callback: (err: ?Error, addresses: Array<any>) => void
920 + ): void;
921 +
922 + declare function resolve6(
923 + domain: string,
924 + callback: (err: ?Error, addresses: Array<any>) => void
925 + ): void;
926 +
927 + declare function resolveCname(
928 + domain: string,
929 + callback: (err: ?Error, addresses: Array<any>) => void
930 + ): void;
931 +
932 + declare function resolveMx(
933 + domain: string,
934 + callback: (err: ?Error, addresses: Array<any>) => void
935 + ): void;
936 +
937 + declare function resolveNs(
938 + domain: string,
939 + callback: (err: ?Error, addresses: Array<any>) => void
940 + ): void;
941 +
942 + declare function resolveSrv(
943 + domain: string,
944 + callback: (err: ?Error, addresses: Array<any>) => void
945 + ): void;
946 +
947 + declare function resolveTxt(
948 + domain: string,
949 + callback: (err: ?Error, addresses: Array<any>) => void
950 + ): void;
951 +
952 + declare function reverse(
953 + ip: string,
954 + callback: (err: ?Error, domains: Array<any>) => void
955 + ): void;
956 + declare function timingSafeEqual(
957 + a: Buffer | $TypedArray | DataView,
958 + b: Buffer | $TypedArray | DataView
959 + ): boolean;
960 +}
961 +
962 +declare class events$EventEmitter {
963 + // deprecated
964 + static listenerCount(emitter: events$EventEmitter, event: string): number;
965 + static defaultMaxListeners: number;
966 +
967 + addListener(event: string, listener: Function): this;
968 + emit(event: string, ...args: Array<any>): boolean;
969 + eventNames(): Array<string>;
970 + listeners(event: string): Array<Function>;
971 + listenerCount(event: string): number;
972 + on(event: string, listener: Function): this;
973 + once(event: string, listener: Function): this;
974 + prependListener(event: string, listener: Function): this;
975 + prependOnceListener(event: string, listener: Function): this;
976 + removeAllListeners(event?: string): this;
977 + removeListener(event: string, listener: Function): this;
978 + off(event: string, listener: Function): this;
979 + setMaxListeners(n: number): this;
980 + getMaxListeners(): number;
981 + rawListeners(event: string): Array<Function>;
982 +}
983 +
984 +declare module 'events' {
985 + // TODO: See the comment above the events$EventEmitter declaration
986 + declare class EventEmitter extends events$EventEmitter {
987 + static EventEmitter: typeof EventEmitter;
988 + }
989 +
990 + declare module.exports: typeof EventEmitter;
991 +}
992 +
993 +declare class domain$Domain extends events$EventEmitter {
994 + members: Array<any>;
995 +
996 + add(emitter: events$EventEmitter): void;
997 + bind(callback: Function): Function;
998 + dispose(): void;
999 + enter(): void;
1000 + exit(): void;
1001 + intercept(callback: Function): Function;
1002 + remove(emitter: events$EventEmitter): void;
1003 + run(fn: Function): void;
1004 +}
1005 +
1006 +declare module 'domain' {
1007 + declare function create(): domain$Domain;
1008 +}
1009 +
1010 +declare module 'fs' {
1011 + declare class Stats {
1012 + dev: number;
1013 + ino: number;
1014 + mode: number;
1015 + nlink: number;
1016 + uid: number;
1017 + gid: number;
1018 + rdev: number;
1019 + size: number;
1020 + blksize: number;
1021 + blocks: number;
1022 + atimeMs: number;
1023 + mtimeMs: number;
1024 + ctimeMs: number;
1025 + birthtimeMs: number;
1026 + atime: Date;
1027 + mtime: Date;
1028 + ctime: Date;
1029 + birthtime: Date;
1030 +
1031 + isFile(): boolean;
1032 + isDirectory(): boolean;
1033 + isBlockDevice(): boolean;
1034 + isCharacterDevice(): boolean;
1035 + isSymbolicLink(): boolean;
1036 + isFIFO(): boolean;
1037 + isSocket(): boolean;
1038 + }
1039 +
1040 + declare type PathLike = string | Buffer | URL;
1041 +
1042 + declare class FSWatcher extends events$EventEmitter {
1043 + close(): void;
1044 + }
1045 +
1046 + declare class ReadStream extends stream$Readable {
1047 + close(): void;
1048 + }
1049 +
1050 + declare class WriteStream extends stream$Writable {
1051 + close(): void;
1052 + bytesWritten: number;
1053 + }
1054 +
1055 + declare class Dirent {
1056 + name: string | Buffer;
1057 +
1058 + isBlockDevice(): boolean;
1059 + isCharacterDevice(): boolean;
1060 + isDirectory(): boolean;
1061 + isFIFO(): boolean;
1062 + isFile(): boolean;
1063 + isSocket(): boolean;
1064 + isSymbolicLink(): boolean;
1065 + }
1066 +
1067 + declare function rename(
1068 + oldPath: string,
1069 + newPath: string,
1070 + callback?: (err: ?ErrnoError) => void
1071 + ): void;
1072 + declare function renameSync(oldPath: string, newPath: string): void;
1073 + declare function ftruncate(
1074 + fd: number,
1075 + len: number,
1076 + callback?: (err: ?ErrnoError) => void
1077 + ): void;
1078 + declare function ftruncateSync(fd: number, len: number): void;
1079 + declare function truncate(
1080 + path: string,
1081 + len: number,
1082 + callback?: (err: ?ErrnoError) => void
1083 + ): void;
1084 + declare function truncateSync(path: string, len: number): void;
1085 + declare function chown(
1086 + path: string,
1087 + uid: number,
1088 + gid: number,
1089 + callback?: (err: ?ErrnoError) => void
1090 + ): void;
1091 + declare function chownSync(path: string, uid: number, gid: number): void;
1092 + declare function fchown(
1093 + fd: number,
1094 + uid: number,
1095 + gid: number,
1096 + callback?: (err: ?ErrnoError) => void
1097 + ): void;
1098 + declare function fchownSync(fd: number, uid: number, gid: number): void;
1099 + declare function lchown(
1100 + path: string,
1101 + uid: number,
1102 + gid: number,
1103 + callback?: (err: ?ErrnoError) => void
1104 + ): void;
1105 + declare function lchownSync(path: string, uid: number, gid: number): void;
1106 + declare function chmod(
1107 + path: string,
1108 + mode: number | string,
1109 + callback?: (err: ?ErrnoError) => void
1110 + ): void;
1111 + declare function chmodSync(path: string, mode: number | string): void;
1112 + declare function fchmod(
1113 + fd: number,
1114 + mode: number | string,
1115 + callback?: (err: ?ErrnoError) => void
1116 + ): void;
1117 + declare function fchmodSync(fd: number, mode: number | string): void;
1118 + declare function lchmod(
1119 + path: string,
1120 + mode: number | string,
1121 + callback?: (err: ?ErrnoError) => void
1122 + ): void;
1123 + declare function lchmodSync(path: string, mode: number | string): void;
1124 + declare function stat(
1125 + path: string,
1126 + callback?: (err: ?ErrnoError, stats: Stats) => any
1127 + ): void;
1128 + declare function statSync(path: string): Stats;
1129 + declare function fstat(
1130 + fd: number,
1131 + callback?: (err: ?ErrnoError, stats: Stats) => any
1132 + ): void;
1133 + declare function fstatSync(fd: number): Stats;
1134 + declare function lstat(
1135 + path: string,
1136 + callback?: (err: ?ErrnoError, stats: Stats) => any
1137 + ): void;
1138 + declare function lstatSync(path: string): Stats;
1139 + declare function link(
1140 + srcpath: string,
1141 + dstpath: string,
1142 + callback?: (err: ?ErrnoError) => void
1143 + ): void;
1144 + declare function linkSync(srcpath: string, dstpath: string): void;
1145 + declare function symlink(
1146 + srcpath: string,
1147 + dtspath: string,
1148 + type?: string,
1149 + callback?: (err: ?ErrnoError) => void
1150 + ): void;
1151 + declare function symlinkSync(
1152 + srcpath: string,
1153 + dstpath: string,
1154 + type?: string
1155 + ): void;
1156 + declare function readlink(
1157 + path: string,
1158 + callback: (err: ?ErrnoError, linkString: string) => void
1159 + ): void;
1160 + declare function readlinkSync(path: string): string;
1161 + declare function realpath(
1162 + path: string,
1163 + cache?: Object,
1164 + callback?: (err: ?ErrnoError, resolvedPath: string) => void
1165 + ): void;
1166 + declare function realpathSync(path: string, cache?: Object): string;
1167 + declare function unlink(
1168 + path: string,
1169 + callback?: (err: ?ErrnoError) => void
1170 + ): void;
1171 + declare function unlinkSync(path: string): void;
1172 +
1173 + declare type RmDirOptions = {|
1174 + /**
1175 + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
1176 + * `EPERM` error is encountered, Node.js will retry the operation with a linear
1177 + * backoff wait of `retryDelay` ms longer on each try. This option represents the
1178 + * number of retries. This option is ignored if the `recursive` option is not
1179 + * `true`.
1180 + * @default 0
1181 + */
1182 + maxRetries?: number | void,
1183 + /**
1184 + * @deprecated since v14.14.0 In future versions of Node.js and will trigger a warning
1185 + * `fs.rmdir(path, { recursive: true })` will throw if `path` does not exist or is a file.
1186 + * Use `fs.rm(path, { recursive: true, force: true })` instead.
1187 + *
1188 + * If `true`, perform a recursive directory removal. In
1189 + * recursive mode soperations are retried on failure.
1190 + * @default false
1191 + */
1192 + recursive?: boolean | void,
1193 + /**
1194 + * The amount of time in milliseconds to wait between retries.
1195 + * This option is ignored if the `recursive` option is not `true`.
1196 + * @default 100
1197 + */
1198 + retryDelay?: number | void,
1199 + |};
1200 +
1201 + declare function rmdir(
1202 + path: PathLike,
1203 + callback?: (err: ?ErrnoError) => void
1204 + ): void;
1205 + declare function rmdir(
1206 + path: PathLike,
1207 + options: RmDirOptions,
1208 + callback?: (err: ?ErrnoError) => void
1209 + ): void;
1210 + declare function rmdirSync(path: PathLike, options?: RmDirOptions): void;
1211 +
1212 + declare type RmOptions = {|
1213 + /**
1214 + * When `true`, exceptions will be ignored if `path` does not exist.
1215 + * @default false
1216 + */
1217 + force?: boolean | void,
1218 + /**
1219 + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
1220 + * `EPERM` error is encountered, Node.js will retry the operation with a linear
1221 + * backoff wait of `retryDelay` ms longer on each try. This option represents the
1222 + * number of retries. This option is ignored if the `recursive` option is not
1223 + * `true`.
1224 + * @default 0
1225 + */
1226 + maxRetries?: number | void,
1227 + /**
1228 + * If `true`, perform a recursive directory removal. In
1229 + * recursive mode, operations are retried on failure.
1230 + * @default false
1231 + */
1232 + recursive?: boolean | void,
1233 + /**
1234 + * The amount of time in milliseconds to wait between retries.
1235 + * This option is ignored if the `recursive` option is not `true`.
1236 + * @default 100
1237 + */
1238 + retryDelay?: number | void,
1239 + |};
1240 +
1241 + /**
1242 + * Asynchronously removes files and directories (modeled on the standard POSIX `rm`utility). No arguments other than a possible exception are given to the
1243 + * completion callback.
1244 + * @since v14.14.0
1245 + */
1246 + declare function rm(
1247 + path: PathLike,
1248 + callback?: (err: ?ErrnoError) => void
1249 + ): void;
1250 + declare function rm(
1251 + path: PathLike,
1252 + options: RmOptions,
1253 + callback?: (err: ?ErrnoError) => void
1254 + ): void;
1255 +
1256 + /**
1257 + * Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`.
1258 + * @since v14.14.0
1259 + */
1260 + declare function rmSync(path: PathLike, options?: RmOptions): void;
1261 +
1262 + declare function mkdir(
1263 + path: string,
1264 + mode?:
1265 + | number
1266 + | {
1267 + recursive?: boolean,
1268 + mode?: number,
1269 + ...
1270 + },
1271 + callback?: (err: ?ErrnoError) => void
1272 + ): void;
1273 + declare function mkdirSync(
1274 + path: string,
1275 + mode?:
1276 + | number
1277 + | {
1278 + recursive?: boolean,
1279 + mode?: number,
1280 + ...
1281 + }
1282 + ): void;
1283 + declare function mkdtemp(
1284 + prefix: string,
1285 + callback: (err: ?ErrnoError, folderPath: string) => void
1286 + ): void;
1287 + declare function mkdtempSync(prefix: string): string;
1288 + declare function readdir(
1289 + path: string,
1290 + options: string | {encoding?: string, withFileTypes?: false, ...},
1291 + callback: (err: ?ErrnoError, files: Array<string>) => void
1292 + ): void;
1293 + declare function readdir(
1294 + path: string,
1295 + options: {encoding?: string, withFileTypes: true, ...},
1296 + callback: (err: ?ErrnoError, files: Array<Dirent>) => void
1297 + ): void;
1298 + declare function readdir(
1299 + path: string,
1300 + callback: (err: ?ErrnoError, files: Array<string>) => void
1301 + ): void;
1302 + declare function readdirSync(
1303 + path: string,
1304 + options?: string | {encoding?: string, withFileTypes?: false, ...}
1305 + ): Array<string>;
1306 + declare function readdirSync(
1307 + path: string,
1308 + options?: string | {encoding?: string, withFileTypes: true, ...}
1309 + ): Array<Dirent>;
1310 + declare function close(
1311 + fd: number,
1312 + callback: (err: ?ErrnoError) => void
1313 + ): void;
1314 + declare function closeSync(fd: number): void;
1315 + declare function open(
1316 + path: string | Buffer | URL,
1317 + flags: string | number,
1318 + mode: number,
1319 + callback: (err: ?ErrnoError, fd: number) => void
1320 + ): void;
1321 + declare function open(
1322 + path: string | Buffer | URL,
1323 + flags: string | number,
1324 + callback: (err: ?ErrnoError, fd: number) => void
1325 + ): void;
1326 + declare function openSync(
1327 + path: string | Buffer,
1328 + flags: string | number,
1329 + mode?: number
1330 + ): number;
1331 + declare function utimes(
1332 + path: string,
1333 + atime: number,
1334 + mtime: number,
1335 + callback?: (err: ?ErrnoError) => void
1336 + ): void;
1337 + declare function utimesSync(path: string, atime: number, mtime: number): void;
1338 + declare function futimes(
1339 + fd: number,
1340 + atime: number,
1341 + mtime: number,
1342 + callback?: (err: ?ErrnoError) => void
1343 + ): void;
1344 + declare function futimesSync(fd: number, atime: number, mtime: number): void;
1345 + declare function fsync(
1346 + fd: number,
1347 + callback?: (err: ?ErrnoError) => void
1348 + ): void;
1349 + declare function fsyncSync(fd: number): void;
1350 + declare function write(
1351 + fd: number,
1352 + buffer: Buffer,
1353 + offset: number,
1354 + length: number,
1355 + position: number,
1356 + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void
1357 + ): void;
1358 + declare function write(
1359 + fd: number,
1360 + buffer: Buffer,
1361 + offset: number,
1362 + length: number,
1363 + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void
1364 + ): void;
1365 + declare function write(
1366 + fd: number,
1367 + buffer: Buffer,
1368 + offset: number,
1369 + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void
1370 + ): void;
1371 + declare function write(
1372 + fd: number,
1373 + buffer: Buffer,
1374 + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void
1375 + ): void;
1376 + declare function write(
1377 + fd: number,
1378 + data: string,
1379 + position: number,
1380 + encoding: string,
1381 + callback: (err: ?ErrnoError, write: number, str: string) => void
1382 + ): void;
1383 + declare function write(
1384 + fd: number,
1385 + data: string,
1386 + position: number,
1387 + callback: (err: ?ErrnoError, write: number, str: string) => void
1388 + ): void;
1389 + declare function write(
1390 + fd: number,
1391 + data: string,
1392 + callback: (err: ?ErrnoError, write: number, str: string) => void
1393 + ): void;
1394 + declare function writeSync(
1395 + fd: number,
1396 + buffer: Buffer,
1397 + offset: number,
1398 + length: number,
1399 + position: number
1400 + ): number;
1401 + declare function writeSync(
1402 + fd: number,
1403 + buffer: Buffer,
1404 + offset: number,
1405 + length: number
1406 + ): number;
1407 + declare function writeSync(
1408 + fd: number,
1409 + buffer: Buffer,
1410 + offset?: number
1411 + ): number;
1412 + declare function writeSync(
1413 + fd: number,
1414 + str: string,
1415 + position: number,
1416 + encoding: string
1417 + ): number;
1418 + declare function writeSync(
1419 + fd: number,
1420 + str: string,
1421 + position?: number
1422 + ): number;
1423 + declare function read(
1424 + fd: number,
1425 + buffer: Buffer,
1426 + offset: number,
1427 + length: number,
1428 + position: ?number,
1429 + callback: (err: ?ErrnoError, bytesRead: number, buffer: Buffer) => void
1430 + ): void;
1431 + declare function readSync(
1432 + fd: number,
1433 + buffer: Buffer,
1434 + offset: number,
1435 + length: number,
1436 + position: number
1437 + ): number;
1438 + declare function readFile(
1439 + path: string | Buffer | URL | number,
1440 + callback: (err: ?ErrnoError, data: Buffer) => void
1441 + ): void;
1442 + declare function readFile(
1443 + path: string | Buffer | URL | number,
1444 + encoding: string,
1445 + callback: (err: ?ErrnoError, data: string) => void
1446 + ): void;
1447 + declare function readFile(
1448 + path: string | Buffer | URL | number,
1449 + options: {
1450 + encoding: string,
1451 + flag?: string,
1452 + ...
1453 + },
1454 + callback: (err: ?ErrnoError, data: string) => void
1455 + ): void;
1456 + declare function readFile(
1457 + path: string | Buffer | URL | number,
1458 + options: {encoding?: null | void, flag?: string, ...},
1459 + callback: (err: ?ErrnoError, data: Buffer) => void
1460 + ): void;
1461 + declare function readFileSync(path: string | Buffer | URL | number): Buffer;
1462 + declare function readFileSync(
1463 + path: string | Buffer | URL | number,
1464 + encoding: string
1465 + ): string;
1466 + declare function readFileSync(
1467 + path: string | Buffer | URL | number,
1468 + options: {
1469 + encoding: string,
1470 + flag?: string,
1471 + ...
1472 + }
1473 + ): string;
1474 + declare function readFileSync(
1475 + path: string | Buffer | URL | number,
1476 + options: {
1477 + encoding?: void,
1478 + flag?: string,
1479 + ...
1480 + }
1481 + ): Buffer;
1482 + declare function writeFile(
1483 + filename: string | Buffer | number,
1484 + data: Buffer | string,
1485 + options:
1486 + | string
1487 + | {
1488 + encoding?: ?string,
1489 + mode?: number,
1490 + flag?: string,
1491 + ...
1492 + },
1493 + callback: (err: ?ErrnoError) => void
1494 + ): void;
1495 + declare function writeFile(
1496 + filename: string | Buffer | number,
1497 + data: Buffer | string,
1498 + callback?: (err: ?ErrnoError) => void
1499 + ): void;
1500 + declare function writeFileSync(
1501 + filename: string,
1502 + data: Buffer | string,
1503 + options?:
1504 + | string
1505 + | {
1506 + encoding?: ?string,
1507 + mode?: number,
1508 + flag?: string,
1509 + ...
1510 + }
1511 + ): void;
1512 + declare function appendFile(
1513 + filename: string | Buffer | number,
1514 + data: string | Buffer,
1515 + options:
1516 + | string
1517 + | {
1518 + encoding?: ?string,
1519 + mode?: number,
1520 + flag?: string,
1521 + ...
1522 + },
1523 + callback: (err: ?ErrnoError) => void
1524 + ): void;
1525 + declare function appendFile(
1526 + filename: string | Buffer | number,
1527 + data: string | Buffer,
1528 + callback: (err: ?ErrnoError) => void
1529 + ): void;
1530 + declare function appendFileSync(
1531 + filename: string | Buffer | number,
1532 + data: string | Buffer,
1533 + options?:
1534 + | string
1535 + | {
1536 + encoding?: ?string,
1537 + mode?: number,
1538 + flag?: string,
1539 + ...
1540 + }
1541 + ): void;
1542 + declare function watchFile(
1543 + filename: string,
1544 + options?: Object,
1545 + listener?: (curr: Stats, prev: Stats) => void
1546 + ): void;
1547 + declare function unwatchFile(
1548 + filename: string,
1549 + listener?: (curr: Stats, prev: Stats) => void
1550 + ): void;
1551 + declare function watch(
1552 + filename: string,
1553 + options?: Object,
1554 + listener?: (event: string, filename: string) => void
1555 + ): FSWatcher;
1556 + declare function exists(
1557 + path: string,
1558 + callback?: (exists: boolean) => void
1559 + ): void;
1560 + declare function existsSync(path: string): boolean;
1561 + declare function access(
1562 + path: string,
1563 + mode?: number,
1564 + callback?: (err: ?ErrnoError) => void
1565 + ): void;
1566 + declare function accessSync(path: string, mode?: number): void;
1567 + declare function createReadStream(path: string, options?: Object): ReadStream;
1568 + declare function createWriteStream(
1569 + path: string,
1570 + options?: Object
1571 + ): WriteStream;
1572 + declare function fdatasync(
1573 + fd: number,
1574 + callback: (err: ?ErrnoError) => void
1575 + ): void;
1576 + declare function fdatasyncSync(fd: number): void;
1577 + declare function copyFile(
1578 + src: string,
1579 + dest: string,
1580 + callback: (err: ErrnoError) => void
1581 + ): void;
1582 + declare function copyFile(
1583 + src: string,
1584 + dest: string,
1585 + flags?: number,
1586 + callback: (err: ErrnoError) => void
1587 + ): void;
1588 + declare function copyFileSync(
1589 + src: string,
1590 + dest: string,
1591 + flags?: number
1592 + ): void;
1593 +
1594 + declare type GlobOptions<WithFileTypes: boolean> = $ReadOnly<{
1595 + /**
1596 + * Current working directory.
1597 + * @default process.cwd()
1598 + */
1599 + cwd?: string | void,
1600 + /**
1601 + * `true` if the glob should return paths as `Dirent`s, `false` otherwise.
1602 + * @default false
1603 + * @since v22.2.0
1604 + */
1605 + withFileTypes?: WithFileTypes,
1606 + /**
1607 + * Function to filter out files/directories or a
1608 + * list of glob patterns to be excluded. If a function is provided, return
1609 + * `true` to exclude the item, `false` to include it.
1610 + * @default undefined
1611 + */
1612 + exclude?:
1613 + | ((fileName: Node$Conditional<WithFileTypes, Dirent, string>) => boolean)
1614 + | $ReadOnlyArray<string>,
1615 + ...
1616 + }>;
1617 +
1618 + /**
1619 + * Retrieves the files matching the specified pattern.
1620 + *
1621 + * ```js
1622 + * import { glob } from 'node:fs';
1623 + *
1624 + * glob('*.js', (err, matches) => {
1625 + * if (err) throw err;
1626 + * console.log(matches);
1627 + * });
1628 + * ```
1629 + * @since v22.0.0
1630 + */
1631 + declare function glob(
1632 + pattern: string | $ReadOnlyArray<string>,
1633 + callback: (err: ?ErrnoError, matches: Array<string>) => void
1634 + ): void;
1635 +
1636 + declare function glob<WithFileTypes: boolean = false>(
1637 + pattern: string | $ReadOnlyArray<string>,
1638 + options: GlobOptions<WithFileTypes>,
1639 + callback: (
1640 + err: ?ErrnoError,
1641 + matches: Node$Conditional<WithFileTypes, Array<Dirent>, Array<string>>
1642 + ) => void
1643 + ): void;
1644 +
1645 + /**
1646 + * ```js
1647 + * import { globSync } from 'node:fs';
1648 + *
1649 + * console.log(globSync('*.js'));
1650 + * ```
1651 + * @since v22.0.0
1652 + * @returns paths of files that match the pattern.
1653 + */
1654 + declare function globSync<WithFileTypes: boolean = false>(
1655 + pattern: string | $ReadOnlyArray<string>,
1656 + options?: GlobOptions<WithFileTypes>
1657 + ): Node$Conditional<WithFileTypes, Array<Dirent>, Array<string>>;
1658 +
1659 + declare var F_OK: number;
1660 + declare var R_OK: number;
1661 + declare var W_OK: number;
1662 + declare var X_OK: number;
1663 + // new var from node 6.x
1664 + // https://nodejs.org/dist/latest-v6.x/docs/api/fs.html#fs_fs_constants_1
1665 + declare var constants: {
1666 + F_OK: number, // 0
1667 + R_OK: number, // 4
1668 + W_OK: number, // 2
1669 + X_OK: number, // 1
1670 + COPYFILE_EXCL: number, // 1
1671 + COPYFILE_FICLONE: number, // 2
1672 + COPYFILE_FICLONE_FORCE: number, // 4
1673 + O_RDONLY: number, // 0
1674 + O_WRONLY: number, // 1
1675 + O_RDWR: number, // 2
1676 + S_IFMT: number, // 61440
1677 + S_IFREG: number, // 32768
1678 + S_IFDIR: number, // 16384
1679 + S_IFCHR: number, // 8192
1680 + S_IFBLK: number, // 24576
1681 + S_IFIFO: number, // 4096
1682 + S_IFLNK: number, // 40960
1683 + S_IFSOCK: number, // 49152
1684 + O_CREAT: number, // 64
1685 + O_EXCL: number, // 128
1686 + O_NOCTTY: number, // 256
1687 + O_TRUNC: number, // 512
1688 + O_APPEND: number, // 1024
1689 + O_DIRECTORY: number, // 65536
1690 + O_NOATIME: number, // 262144
1691 + O_NOFOLLOW: number, // 131072
1692 + O_SYNC: number, // 1052672
1693 + O_DSYNC: number, // 4096
1694 + O_SYMLINK: number, // 2097152
1695 + O_DIRECT: number, // 16384
1696 + O_NONBLOCK: number, // 2048
1697 + S_IRWXU: number, // 448
1698 + S_IRUSR: number, // 256
1699 + S_IWUSR: number, // 128
1700 + S_IXUSR: number, // 64
1701 + S_IRWXG: number, // 56
1702 + S_IRGRP: number, // 32
1703 + S_IWGRP: number, // 16
1704 + S_IXGRP: number, // 8
1705 + S_IRWXO: number, // 7
1706 + S_IROTH: number, // 4
1707 + S_IWOTH: number, // 2
1708 + S_IXOTH: number, // 1
1709 + ...
1710 + };
1711 +
1712 + declare type BufferEncoding = 'buffer' | {encoding: 'buffer', ...};
1713 + declare type EncodingOptions = {encoding?: string, ...};
1714 + declare type EncodingFlag = EncodingOptions & {flag?: string, ...};
1715 + declare type WriteOptions = EncodingFlag & {mode?: number, ...};
1716 + declare type RemoveOptions = {
1717 + force?: boolean,
1718 + maxRetries?: number,
1719 + recursive?: boolean,
1720 + retryDelay?: number,
1721 + ...
1722 + };
1723 + declare class FileHandle {
1724 + appendFile(
1725 + data: string | Buffer,
1726 + options: WriteOptions | string
1727 + ): Promise<void>;
1728 + chmod(mode: number): Promise<void>;
1729 + chown(uid: number, guid: number): Promise<void>;
1730 + close(): Promise<void>;
1731 + datasync(): Promise<void>;
1732 + fd: number;
1733 + read<T: Buffer | Uint8Array>(
1734 + buffer: T,
1735 + offset: number,
1736 + length: number,
1737 + position: number
1738 + ): Promise<{
1739 + bytesRead: number,
1740 + buffer: T,
1741 + ...
1742 + }>;
1743 + readFile(options: EncodingFlag): Promise<Buffer>;
1744 + readFile(options: string): Promise<string>;
1745 + stat(): Promise<Stats>;
1746 + sync(): Promise<void>;
1747 + truncate(len?: number): Promise<void>;
1748 + utimes(
1749 + atime: number | string | Date,
1750 + mtime: number | string | Date
1751 + ): Promise<void>;
1752 + write(
1753 + buffer: Buffer | Uint8Array,
1754 + offset: number,
1755 + length: number,
1756 + position: number
1757 + ): Promise<void>;
1758 + writeFile(
1759 + data: string | Buffer | Uint8Array,
1760 + options: WriteOptions | string
1761 + ): Promise<void>;
1762 + }
1763 +
1764 + declare type FSPromisePath = string | Buffer | URL;
1765 + declare type FSPromise = {
1766 + access(path: FSPromisePath, mode?: number): Promise<void>,
1767 + appendFile(
1768 + path: FSPromisePath | FileHandle,
1769 + data: string | Buffer,
1770 + options?: WriteOptions | string
1771 + ): Promise<void>,
1772 + chmod(path: FSPromisePath, mode: number): Promise<void>,
1773 + chown(path: FSPromisePath, uid: number, gid: number): Promise<void>,
1774 + copyFile(
1775 + src: FSPromisePath,
1776 + dest: FSPromisePath,
1777 + flags?: number
1778 + ): Promise<void>,
1779 + fchmod(filehandle: FileHandle, mode: number): Promise<void>,
1780 + fchown(filehandle: FileHandle, uid: number, guid: number): Promise<void>,
1781 + fdatasync(filehandle: FileHandle): Promise<void>,
1782 + fstat(filehandle: FileHandle): Promise<Stats>,
1783 + fsync(filehandle: FileHandle): Promise<void>,
1784 + ftruncate(filehandle: FileHandle, len?: number): Promise<void>,
1785 + futimes(
1786 + filehandle: FileHandle,
1787 + atime: number | string | Date,
1788 + mtime: number | string | Date
1789 + ): Promise<void>,
1790 + lchmod(path: FSPromisePath, mode: number): Promise<void>,
1791 + glob<WithFileTypes: boolean = false>(
1792 + pattern: string | $ReadOnlyArray<string>,
1793 + options?: GlobOptions<WithFileTypes>
1794 + ): Node$Conditional<
1795 + WithFileTypes,
1796 + AsyncIterator<Dirent>,
1797 + AsyncIterator<string>,
1798 + >,
1799 + lchown(path: FSPromisePath, uid: number, guid: number): Promise<void>,
1800 + link(existingPath: FSPromisePath, newPath: FSPromisePath): Promise<void>,
1801 + lstat(path: FSPromisePath): Promise<Stats>,
1802 + mkdir(
1803 + path: FSPromisePath,
1804 + mode?:
1805 + | number
1806 + | {
1807 + recursive?: boolean,
1808 + mode?: number,
1809 + ...
1810 + }
1811 + ): Promise<void>,
1812 + mkdtemp(prefix: string, options?: EncodingOptions): Promise<string>,
1813 + open(
1814 + path: FSPromisePath,
1815 + flags?: string | number,
1816 + mode?: number
1817 + ): Promise<FileHandle>,
1818 + read<T: Buffer | Uint8Array>(
1819 + filehandle: FileHandle,
1820 + buffer: T,
1821 + offset: number,
1822 + length: number,
1823 + position?: number
1824 + ): Promise<{
1825 + bytesRead: number,
1826 + buffer: T,
1827 + ...
1828 + }>,
1829 + readdir: ((
1830 + path: FSPromisePath,
1831 + options: string | {encoding?: string, withFileTypes?: false, ...}
1832 + ) => Promise<Array<string>>) &
1833 + ((
1834 + path: FSPromisePath,
1835 + options: {encoding?: string, withFileTypes: true, ...}
1836 + ) => Promise<Array<Dirent>>) &
1837 + ((path: FSPromisePath) => Promise<Array<string>>),
1838 + readFile: ((
1839 + path: FSPromisePath | FileHandle,
1840 + options: string
1841 + ) => Promise<string>) &
1842 + ((
1843 + path: FSPromisePath | FileHandle,
1844 + options?: EncodingFlag
1845 + ) => Promise<Buffer>),
1846 + readlink: ((
1847 + path: FSPromisePath,
1848 + options: BufferEncoding
1849 + ) => Promise<Buffer>) &
1850 + ((
1851 + path: FSPromisePath,
1852 + options?: string | EncodingOptions
1853 + ) => Promise<string>),
1854 + realpath: ((
1855 + path: FSPromisePath,
1856 + options: BufferEncoding
1857 + ) => Promise<Buffer>) &
1858 + ((
1859 + path: FSPromisePath,
1860 + options?: string | EncodingOptions
1861 + ) => Promise<string>),
1862 + rename(oldPath: FSPromisePath, newPath: FSPromisePath): Promise<void>,
1863 + rm(path: FSPromisePath, options?: RemoveOptions): Promise<void>,
1864 + rmdir(path: FSPromisePath): Promise<void>,
1865 + stat(path: FSPromisePath): Promise<Stats>,
1866 + symlink(
1867 + target: FSPromisePath,
1868 + path: FSPromisePath,
1869 + type?: 'dir' | 'file' | 'junction'
1870 + ): Promise<void>,
1871 + truncate(path: FSPromisePath, len?: number): Promise<void>,
1872 + unlink(path: FSPromisePath): Promise<void>,
1873 + utimes(
1874 + path: FSPromisePath,
1875 + atime: number | string | Date,
1876 + mtime: number | string | Date
1877 + ): Promise<void>,
1878 + write<T: Buffer | Uint8Array>(
1879 + filehandle: FileHandle,
1880 + buffer: T,
1881 + offset: number,
1882 + length: number,
1883 + position?: number
1884 + ): Promise<{
1885 + bytesRead: number,
1886 + buffer: T,
1887 + ...
1888 + }>,
1889 + writeFile(
1890 + FSPromisePath | FileHandle,
1891 + data: string | Buffer | Uint8Array,
1892 + options?: string | WriteOptions
1893 + ): Promise<void>,
1894 + ...
1895 + };
1896 +
1897 + declare var promises: FSPromise;
1898 +}
1899 +
1900 +type http$agentOptions = {
1901 + keepAlive?: boolean,
1902 + keepAliveMsecs?: number,
1903 + maxSockets?: number,
1904 + maxFreeSockets?: number,
1905 + ...
1906 +};
1907 +
1908 +declare class http$Agent<+SocketT = net$Socket> {
1909 + constructor(options: http$agentOptions): void;
1910 + destroy(): void;
1911 + freeSockets: {[name: string]: $ReadOnlyArray<SocketT>, ...};
1912 + getName(options: {
1913 + host: string,
1914 + port: number,
1915 + localAddress: string,
1916 + ...
1917 + }): string;
1918 + maxFreeSockets: number;
1919 + maxSockets: number;
1920 + requests: {[name: string]: $ReadOnlyArray<http$ClientRequest<SocketT>>, ...};
1921 + sockets: {[name: string]: $ReadOnlyArray<SocketT>, ...};
1922 +}
1923 +
1924 +declare class http$IncomingMessage<SocketT = net$Socket>
1925 + extends stream$Readable
1926 +{
1927 + headers: Object;
1928 + rawHeaders: Array<string>;
1929 + httpVersion: string;
1930 + method: string;
1931 + trailers: Object;
1932 + setTimeout(msecs: number, callback: Function): void;
1933 + socket: SocketT;
1934 + statusCode: number;
1935 + statusMessage: string;
1936 + url: string;
1937 + aborted: boolean;
1938 + complete: boolean;
1939 + rawTrailers: Array<string>;
1940 +}
1941 +
1942 +declare class http$ClientRequest<+SocketT = net$Socket>
1943 + extends stream$Writable
1944 +{
1945 + abort(): void;
1946 + aborted: boolean;
1947 + +connection: SocketT | null;
1948 + flushHeaders(): void;
1949 + getHeader(name: string): string;
1950 + removeHeader(name: string): void;
1951 + setHeader(name: string, value: string | Array<string>): void;
1952 + setNoDelay(noDelay?: boolean): void;
1953 + setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
1954 + setTimeout(msecs: number, callback?: Function): void;
1955 + +socket: SocketT | null;
1956 +}
1957 +
1958 +declare class http$ServerResponse extends stream$Writable {
1959 + addTrailers(headers: {[key: string]: string, ...}): void;
1960 + connection: net$Socket;
1961 + finished: boolean;
1962 + flushHeaders(): void;
1963 + getHeader(name: string): string;
1964 + getHeaderNames(): Array<string>;
1965 + getHeaders(): {[key: string]: string | Array<string>, ...};
1966 + hasHeader(name: string): boolean;
1967 + headersSent: boolean;
1968 + removeHeader(name: string): void;
1969 + sendDate: boolean;
1970 + setHeader(name: string, value: string | Array<string>): void;
1971 + setTimeout(msecs: number, callback?: Function): http$ServerResponse;
1972 + socket: net$Socket;
1973 + statusCode: number;
1974 + statusMessage: string;
1975 + writeContinue(): void;
1976 + writeHead(
1977 + status: number,
1978 + statusMessage?: string,
1979 + headers?: {[key: string]: string, ...}
1980 + ): void;
1981 + writeHead(status: number, headers?: {[key: string]: string, ...}): void;
1982 + writeProcessing(): void;
1983 +}
1984 +
1985 +declare class http$Server extends net$Server {
1986 + listen(
1987 + port?: number,
1988 + hostname?: string,
1989 + backlog?: number,
1990 + callback?: Function
1991 + ): this;
1992 + // The following signatures are added to allow omitting intermediate arguments
1993 + listen(port?: number, backlog?: number, callback?: Function): this;
1994 + listen(port?: number, hostname?: string, callback?: Function): this;
1995 + listen(port?: number, callback?: Function): this;
1996 + listen(path: string, callback?: Function): this;
1997 + listen(
1998 + handle: {
1999 + port?: number,
2000 + host?: string,
2001 + path?: string,
2002 + backlog?: number,
2003 + exclusive?: boolean,
2004 + readableAll?: boolean,
2005 + writableAll?: boolean,
2006 + ipv6Only?: boolean,
2007 + ...
2008 + },
2009 + callback?: Function
2010 + ): this;
2011 + listening: boolean;
2012 + close(callback?: (error: ?Error) => mixed): this;
2013 + closeAllConnections(): void;
2014 + closeIdleConnections(): void;
2015 + maxHeadersCount: number;
2016 + keepAliveTimeout: number;
2017 + headersTimeout: number;
2018 + setTimeout(msecs: number, callback: Function): this;
2019 + timeout: number;
2020 +}
2021 +
2022 +declare class https$Server extends tls$Server {
2023 + listen(
2024 + port?: number,
2025 + hostname?: string,
2026 + backlog?: number,
2027 + callback?: Function
2028 + ): this;
2029 + // The following signatures are added to allow omitting intermediate arguments
2030 + listen(port?: number, backlog?: number, callback?: Function): this;
2031 + listen(port?: number, hostname?: string, callback?: Function): this;
2032 + listen(port?: number, callback?: Function): this;
2033 + listen(path: string, callback?: Function): this;
2034 + listen(
2035 + handle: {
2036 + port?: number,
2037 + host?: string,
2038 + path?: string,
2039 + backlog?: number,
2040 + exclusive?: boolean,
2041 + readableAll?: boolean,
2042 + writableAll?: boolean,
2043 + ipv6Only?: boolean,
2044 + ...
2045 + },
2046 + callback?: Function
2047 + ): this;
2048 + close(callback?: (error: ?Error) => mixed): this;
2049 + closeAllConnections(): void;
2050 + closeIdleConnections(): void;
2051 + keepAliveTimeout: number;
2052 + headersTimeout: number;
2053 + setTimeout(msecs: number, callback: Function): this;
2054 + timeout: number;
2055 +}
2056 +
2057 +type requestOptions = {|
2058 + auth?: string,
2059 + defaultPort?: number,
2060 + family?: number,
2061 + headers?: {[key: string]: mixed, ...},
2062 + host?: string,
2063 + hostname?: string,
2064 + localAddress?: string,
2065 + method?: string,
2066 + path?: string,
2067 + port?: number,
2068 + protocol?: string,
2069 + setHost?: boolean,
2070 + socketPath?: string,
2071 + timeout?: number,
2072 +|};
2073 +
2074 +type http$requestOptions = {
2075 + ...requestOptions,
2076 + agent?: boolean | http$Agent<net$Socket>,
2077 + createConnection?: (
2078 + options: net$connectOptions,
2079 + callback?: Function
2080 + ) => net$Socket,
2081 + ...
2082 +};
2083 +
2084 +declare module 'http' {
2085 + declare class Server extends http$Server {}
2086 + declare class Agent extends http$Agent<net$Socket> {
2087 + createConnection(
2088 + options: net$connectOptions,
2089 + callback?: Function
2090 + ): net$Socket;
2091 + }
2092 + declare class ClientRequest extends http$ClientRequest<net$Socket> {}
2093 + declare class IncomingMessage extends http$IncomingMessage<net$Socket> {}
2094 + declare class ServerResponse extends http$ServerResponse {}
2095 +
2096 + declare function createServer(
2097 + requestListener?: (
2098 + request: IncomingMessage,
2099 + response: ServerResponse
2100 + ) => void
2101 + ): Server;
2102 + declare function request(
2103 + options: http$requestOptions,
2104 + callback?: (response: IncomingMessage) => void
2105 + ): ClientRequest;
2106 + declare function request(
2107 + url: string,
2108 + options?: http$requestOptions,
2109 + callback?: (response: IncomingMessage) => void
2110 + ): ClientRequest;
2111 + declare function get(
2112 + options: http$requestOptions,
2113 + callback?: (response: IncomingMessage) => void
2114 + ): ClientRequest;
2115 + declare function get(
2116 + url: string,
2117 + options?: http$requestOptions,
2118 + callback?: (response: IncomingMessage) => void
2119 + ): ClientRequest;
2120 +
2121 + declare var METHODS: Array<string>;
2122 + declare var STATUS_CODES: {[key: number]: string, ...};
2123 + declare var globalAgent: Agent;
2124 +}
2125 +
2126 +type https$requestOptions = {
2127 + ...requestOptions,
2128 + agent?: boolean | http$Agent<tls$TLSSocket>,
2129 + createConnection?: (
2130 + options: tls$connectOptions,
2131 + callback?: Function
2132 + ) => tls$TLSSocket,
2133 + ...
2134 +};
2135 +
2136 +declare module 'https' {
2137 + declare class Server extends https$Server {}
2138 + declare class Agent extends http$Agent<tls$TLSSocket> {
2139 + createConnection(
2140 + port: ?number,
2141 + host: ?string,
2142 + options: tls$connectOptions
2143 + ): tls$TLSSocket;
2144 + createConnection(port: ?number, options: tls$connectOptions): tls$TLSSocket;
2145 + createConnection(options: tls$connectOptions): tls$TLSSocket;
2146 + }
2147 +
2148 + declare class ClientRequest extends http$ClientRequest<tls$TLSSocket> {}
2149 + declare class IncomingMessage extends http$IncomingMessage<tls$TLSSocket> {}
2150 + declare class ServerResponse extends http$ServerResponse {}
2151 +
2152 + declare function createServer(
2153 + options: Object,
2154 + requestListener?: (
2155 + request: IncomingMessage,
2156 + response: ServerResponse
2157 + ) => void
2158 + ): Server;
2159 + declare function request(
2160 + options: https$requestOptions,
2161 + callback?: (response: IncomingMessage) => void
2162 + ): ClientRequest;
2163 + declare function request(
2164 + url: string,
2165 + options?: https$requestOptions,
2166 + callback?: (response: IncomingMessage) => void
2167 + ): ClientRequest;
2168 + declare function get(
2169 + options: https$requestOptions,
2170 + callback?: (response: IncomingMessage) => void
2171 + ): ClientRequest;
2172 + declare function get(
2173 + url: string,
2174 + options?: https$requestOptions,
2175 + callback?: (response: IncomingMessage) => void
2176 + ): ClientRequest;
2177 +
2178 + declare var globalAgent: Agent;
2179 +}
2180 +
2181 +type module$Module = {
2182 + builtinModules: Array<string>,
2183 + createRequire(filename: string | URL): typeof require,
2184 + syncBuiltinESMExports(): void,
2185 + Module: module$Module,
2186 + ...
2187 +};
2188 +
2189 +declare module 'module' {
2190 + declare module.exports: module$Module;
2191 +}
2192 +
2193 +declare class net$Socket extends stream$Duplex {
2194 + constructor(options?: Object): void;
2195 + address(): net$Socket$address;
2196 + bufferSize: number;
2197 + bytesRead: number;
2198 + bytesWritten: number;
2199 + connect(path: string, connectListener?: () => mixed): net$Socket;
2200 + connect(
2201 + port: number,
2202 + host?: string,
2203 + connectListener?: () => mixed
2204 + ): net$Socket;
2205 + connect(port: number, connectListener?: () => mixed): net$Socket;
2206 + connect(options: Object, connectListener?: () => mixed): net$Socket;
2207 + destroyed: boolean;
2208 + end(
2209 + chunkOrEncodingOrCallback?:
2210 + | Buffer
2211 + | Uint8Array
2212 + | string
2213 + | ((data: any) => void),
2214 + encodingOrCallback?: string | ((data: any) => void),
2215 + callback?: (data: any) => void
2216 + ): this;
2217 + localAddress: string;
2218 + localPort: number;
2219 + pause(): this;
2220 + ref(): this;
2221 + remoteAddress: string | void;
2222 + remoteFamily: string;
2223 + remotePort: number;
2224 + resume(): this;
2225 + setEncoding(encoding?: string): this;
2226 + setKeepAlive(enable?: boolean, initialDelay?: number): this;
2227 + setNoDelay(noDelay?: boolean): this;
2228 + setTimeout(timeout: number, callback?: Function): this;
2229 + unref(): this;
2230 + write(
2231 + chunk: Buffer | Uint8Array | string,
2232 + encodingOrCallback?: string | ((data: any) => void),
2233 + callback?: (data: any) => void
2234 + ): boolean;
2235 +}
2236 +
2237 +declare class net$Server extends events$EventEmitter {
2238 + listen(
2239 + port?: number,
2240 + hostname?: string,
2241 + backlog?: number,
2242 + callback?: Function
2243 + ): net$Server;
2244 + listen(path: string, callback?: Function): net$Server;
2245 + listen(handle: Object, callback?: Function): net$Server;
2246 + listening: boolean;
2247 + close(callback?: Function): net$Server;
2248 + address(): net$Socket$address;
2249 + connections: number;
2250 + maxConnections: number;
2251 + getConnections(callback: Function): void;
2252 + ref(): net$Server;
2253 + unref(): net$Server;
2254 +}
2255 +
2256 +type net$connectOptions = {
2257 + port?: number,
2258 + host?: string,
2259 + localAddress?: string,
2260 + localPort?: number,
2261 + family?: number,
2262 + lookup?: (
2263 + domain: string,
2264 + options?: ?number | ?Object,
2265 + callback?: (err: ?Error, address: string, family: number) => void
2266 + ) => mixed,
2267 + path?: string,
2268 + ...
2269 +};
2270 +
2271 +declare module 'net' {
2272 + declare class Server extends net$Server {}
2273 + declare class Socket extends net$Socket {}
2274 +
2275 + declare function isIP(input: string): number;
2276 + declare function isIPv4(input: string): boolean;
2277 + declare function isIPv6(input: string): boolean;
2278 +
2279 + declare type connectionListener = (socket: Socket) => any;
2280 + declare function createServer(
2281 + options?:
2282 + | {
2283 + allowHalfOpen?: boolean,
2284 + pauseOnConnect?: boolean,
2285 + ...
2286 + }
2287 + | connectionListener,
2288 + connectionListener?: connectionListener
2289 + ): Server;
2290 +
2291 + declare type connectListener = () => any;
2292 + declare function connect(
2293 + pathOrPortOrOptions: string | number | net$connectOptions,
2294 + hostOrConnectListener?: string | connectListener,
2295 + connectListener?: connectListener
2296 + ): Socket;
2297 +
2298 + declare function createConnection(
2299 + pathOrPortOrOptions: string | number | net$connectOptions,
2300 + hostOrConnectListener?: string | connectListener,
2301 + connectListener?: connectListener
2302 + ): Socket;
2303 +}
2304 +
2305 +type os$CPU = {
2306 + model: string,
2307 + speed: number,
2308 + times: {
2309 + idle: number,
2310 + irq: number,
2311 + nice: number,
2312 + sys: number,
2313 + user: number,
2314 + ...
2315 + },
2316 + ...
2317 +};
2318 +
2319 +type os$NetIFAddr = {
2320 + address: string,
2321 + family: string,
2322 + internal: boolean,
2323 + mac: string,
2324 + netmask: string,
2325 + ...
2326 +};
2327 +
2328 +type os$UserInfo$buffer = {
2329 + uid: number,
2330 + gid: number,
2331 + username: Buffer,
2332 + homedir: Buffer,
2333 + shell: ?Buffer,
2334 + ...
2335 +};
2336 +
2337 +type os$UserInfo$string = {
2338 + uid: number,
2339 + gid: number,
2340 + username: string,
2341 + homedir: string,
2342 + shell: ?string,
2343 + ...
2344 +};
2345 +
2346 +declare module 'os' {
2347 + declare function arch(): 'x64' | 'arm' | 'ia32';
2348 + declare function availableParallelism(): number;
2349 + declare function cpus(): Array<os$CPU>;
2350 + declare function endianness(): 'BE' | 'LE';
2351 + declare function freemem(): number;
2352 + declare function homedir(): string;
2353 + declare function hostname(): string;
2354 + declare function loadavg(): [number, number, number];
2355 + declare function networkInterfaces(): {
2356 + [ifName: string]: Array<os$NetIFAddr>,
2357 + ...
2358 + };
2359 + declare function platform(): string;
2360 + declare function release(): string;
2361 + declare function tmpdir(): string;
2362 + declare function totalmem(): number;
2363 + declare function type(): string;
2364 + declare function uptime(): number;
2365 + declare function userInfo(options: {
2366 + encoding: 'buffer',
2367 + ...
2368 + }): os$UserInfo$buffer;
2369 + declare function userInfo(options?: {
2370 + encoding: 'utf8',
2371 + ...
2372 + }): os$UserInfo$string;
2373 + declare var EOL: string;
2374 +}
2375 +
2376 +declare module 'path' {
2377 + declare function normalize(path: string): string;
2378 + declare function join(...parts: Array<string>): string;
2379 + declare function resolve(...parts: Array<string>): string;
2380 + declare function isAbsolute(path: string): boolean;
2381 + declare function relative(from: string, to: string): string;
2382 + declare function dirname(path: string): string;
2383 + declare function basename(path: string, ext?: string): string;
2384 + declare function extname(path: string): string;
2385 + declare var sep: string;
2386 + declare var delimiter: string;
2387 + declare function parse(pathString: string): {
2388 + root: string,
2389 + dir: string,
2390 + base: string,
2391 + ext: string,
2392 + name: string,
2393 + ...
2394 + };
2395 + declare function format(pathObject: {
2396 + root?: string,
2397 + dir?: string,
2398 + base?: string,
2399 + ext?: string,
2400 + name?: string,
2401 + ...
2402 + }): string;
2403 + declare var posix: any;
2404 + declare var win32: any;
2405 +}
2406 +
2407 +declare module 'punycode' {
2408 + declare function decode(string: string): string;
2409 + declare function encode(string: string): string;
2410 + declare function toASCII(domain: string): string;
2411 + declare function toUnicode(domain: string): string;
2412 + declare var ucs2: {
2413 + decode: (str: string) => Array<number>,
2414 + encode: (codePoints: Array<number>) => string,
2415 + ...
2416 + };
2417 + declare var version: string;
2418 +}
2419 +
2420 +declare module 'querystring' {
2421 + declare function stringify(
2422 + obj: Object,
2423 + separator?: string,
2424 + equal?: string,
2425 + options?: {encodeURIComponent?: (str: string) => string, ...}
2426 + ): string;
2427 + declare function parse(
2428 + str: string,
2429 + separator: ?string,
2430 + equal: ?string,
2431 + options?: {
2432 + decodeURIComponent?: (str: string) => string,
2433 + maxKeys?: number,
2434 + ...
2435 + }
2436 + ): any;
2437 + declare function escape(str: string): string;
2438 + declare function unescape(str: string, decodeSpaces?: boolean): string;
2439 +}
2440 +
2441 +type readline$InterfaceCompleter = (
2442 + line: string
2443 +) =>
2444 + | [Array<string>, string]
2445 + | ((
2446 + line: string,
2447 + ((err: ?Error, data: [Array<string>, string]) => void)
2448 + ) => void);
2449 +
2450 +declare class readline$Interface extends events$EventEmitter {
2451 + close(): void;
2452 + pause(): void;
2453 + prompt(preserveCursor?: boolean): void;
2454 + question(
2455 + query: string,
2456 + optionsOrCallback: {|signal?: AbortSignal|} | ((answer: string) => void),
2457 + callback?: (answer: string) => void
2458 + ): void;
2459 + resume(): void;
2460 + setPrompt(prompt: string): void;
2461 + write(
2462 + val: string | void | null,
2463 + key?: {
2464 + name: string,
2465 + ctrl?: boolean,
2466 + shift?: boolean,
2467 + meta?: boolean,
2468 + ...
2469 + }
2470 + ): void;
2471 + @@asyncIterator(): AsyncIterator<string>;
2472 +}
2473 +
2474 +declare module 'readline' {
2475 + declare var Interface: typeof readline$Interface;
2476 + declare function clearLine(
2477 + stream: stream$Stream,
2478 + dir: -1 | 1 | 0,
2479 + callback?: () => void
2480 + ): void;
2481 + declare function clearScreenDown(
2482 + stream: stream$Stream,
2483 + callback?: () => void
2484 + ): void;
2485 + declare function createInterface(opts: {
2486 + completer?: readline$InterfaceCompleter,
2487 + crlfDelay?: number,
2488 + escapeCodeTimeout?: number,
2489 + historySize?: number,
2490 + input: stream$Readable,
2491 + output?: ?stream$Stream,
2492 + prompt?: string,
2493 + removeHistoryDuplicates?: boolean,
2494 + terminal?: boolean,
2495 + ...
2496 + }): readline$Interface;
2497 + declare function cursorTo(
2498 + stream: stream$Stream,
2499 + x?: number,
2500 + y?: number,
2501 + callback?: () => void
2502 + ): void;
2503 + declare function moveCursor(
2504 + stream: stream$Stream,
2505 + dx: number,
2506 + dy: number,
2507 + callback?: () => void
2508 + ): void;
2509 + declare function emitKeypressEvents(
2510 + stream: stream$Stream,
2511 + readlineInterface?: readline$Interface
2512 + ): void;
2513 +}
2514 +
2515 +declare class stream$Stream extends events$EventEmitter {}
2516 +
2517 +type readableStreamOptions = {
2518 + highWaterMark?: number,
2519 + encoding?: string,
2520 + objectMode?: boolean,
2521 + read?: (size: number) => void,
2522 + destroy?: (error: ?Error, callback: (error?: Error) => void) => void,
2523 + autoDestroy?: boolean,
2524 + ...
2525 +};
2526 +declare class stream$Readable extends stream$Stream {
2527 + static from(
2528 + iterable: Iterable<any> | AsyncIterable<any>,
2529 + options?: readableStreamOptions
2530 + ): stream$Readable;
2531 +
2532 + constructor(options?: readableStreamOptions): void;
2533 + destroy(error?: Error): this;
2534 + isPaused(): boolean;
2535 + pause(): this;
2536 + pipe<T: stream$Writable>(dest: T, options?: {end?: boolean, ...}): T;
2537 + read(size?: number): ?(string | Buffer);
2538 + readable: boolean;
2539 + readableHighWaterMark: number;
2540 + readableLength: number;
2541 + resume(): this;
2542 + setEncoding(encoding: string): this;
2543 + unpipe(dest?: stream$Writable): this;
2544 + unshift(chunk: Buffer | Uint8Array | string): void;
2545 + wrap(oldReadable: stream$Stream): this;
2546 + _read(size: number): void;
2547 + _destroy(error: ?Error, callback: (error?: Error) => void): void;
2548 + push(chunk: ?(Buffer | Uint8Array | string), encoding?: string): boolean;
2549 + @@asyncIterator(): AsyncIterator<string | Buffer>;
2550 +}
2551 +
2552 +type writableStreamOptions = {
2553 + highWaterMark?: number,
2554 + decodeStrings?: boolean,
2555 + defaultEncoding?: string,
2556 + objectMode?: boolean,
2557 + emitClose?: boolean,
2558 + write?: (
2559 + chunk: Buffer | string,
2560 + encoding: string,
2561 + callback: (error?: Error) => void
2562 + ) => void,
2563 + writev?: (
2564 + chunks: Array<{
2565 + chunk: Buffer | string,
2566 + encoding: string,
2567 + ...
2568 + }>,
2569 + callback: (error?: Error) => void
2570 + ) => void,
2571 + destroy?: (error: ?Error, callback: (error?: Error) => void) => void,
2572 + final?: (callback: (error?: Error) => void) => void,
2573 + autoDestroy?: boolean,
2574 + ...
2575 +};
2576 +declare class stream$Writable extends stream$Stream {
2577 + constructor(options?: writableStreamOptions): void;
2578 + cork(): void;
2579 + destroy(error?: Error): this;
2580 + end(callback?: () => void): this;
2581 + end(chunk?: string | Buffer | Uint8Array, callback?: () => void): this;
2582 + end(
2583 + chunk?: string | Buffer | Uint8Array,
2584 + encoding?: string,
2585 + callback?: () => void
2586 + ): this;
2587 + setDefaultEncoding(encoding: string): this;
2588 + uncork(): void;
2589 + writable: boolean;
2590 + writableHighWaterMark: number;
2591 + writableLength: number;
2592 + write(
2593 + chunk: string | Buffer | Uint8Array,
2594 + callback?: (error?: Error) => void
2595 + ): boolean;
2596 + write(
2597 + chunk: string | Buffer | Uint8Array,
2598 + encoding?: string,
2599 + callback?: (error?: Error) => void
2600 + ): boolean;
2601 + _write(
2602 + chunk: Buffer | string,
2603 + encoding: string,
2604 + callback: (error?: Error) => void
2605 + ): void;
2606 + _writev(
2607 + chunks: Array<{
2608 + chunk: Buffer | string,
2609 + encoding: string,
2610 + ...
2611 + }>,
2612 + callback: (error?: Error) => void
2613 + ): void;
2614 + _destroy(error: ?Error, callback: (error?: Error) => void): void;
2615 + _final(callback: (error?: Error) => void): void;
2616 +}
2617 +
2618 +//According to the NodeJS docs:
2619 +//"Since JavaScript doesn't have multiple prototypal inheritance, this class
2620 +//prototypally inherits from Readable, and then parasitically from Writable."
2621 +//Source: <https://nodejs.org/api/stream.html#stream_class_stream_duplex_1
2622 +type duplexStreamOptions = writableStreamOptions &
2623 + readableStreamOptions & {
2624 + allowHalfOpen?: boolean,
2625 + readableObjectMode?: boolean,
2626 + writableObjectMode?: boolean,
2627 + readableHighWaterMark?: number,
2628 + writableHighWaterMark?: number,
2629 + ...
2630 + };
2631 +declare class stream$Duplex extends stream$Readable mixins stream$Writable {
2632 + constructor(options?: duplexStreamOptions): void;
2633 +}
2634 +type transformStreamOptions = duplexStreamOptions & {
2635 + flush?: (callback: (error: ?Error, data: ?(Buffer | string)) => void) => void,
2636 + transform?: (
2637 + chunk: Buffer | string,
2638 + encoding: string,
2639 + callback: (error: ?Error, data: ?(Buffer | string)) => void
2640 + ) => void,
2641 + ...
2642 +};
2643 +declare class stream$Transform extends stream$Duplex {
2644 + constructor(options?: transformStreamOptions): void;
2645 + _flush(callback: (error: ?Error, data: ?(Buffer | string)) => void): void;
2646 + _transform(
2647 + chunk: Buffer | string,
2648 + encoding: string,
2649 + callback: (error: ?Error, data: ?(Buffer | string)) => void
2650 + ): void;
2651 +}
2652 +declare class stream$PassThrough extends stream$Transform {}
2653 +
2654 +declare module 'stream' {
2655 + declare var Stream: typeof stream$Stream;
2656 + declare var Readable: typeof stream$Readable;
2657 + declare var Writable: typeof stream$Writable;
2658 + declare var Duplex: typeof stream$Duplex;
2659 + declare var Transform: typeof stream$Transform;
2660 + declare var PassThrough: typeof stream$PassThrough;
2661 + declare function finished(
2662 + stream: stream$Stream,
2663 + callback: (error?: Error) => void
2664 + ): () => void;
2665 + declare function finished(
2666 + stream: stream$Stream,
2667 + options: ?{
2668 + error?: boolean,
2669 + readable?: boolean,
2670 + writable?: boolean,
2671 + ...
2672 + },
2673 + callback: (error?: Error) => void
2674 + ): () => void;
2675 + declare function pipeline<T: stream$Writable>(
2676 + s1: stream$Readable,
2677 + last: T,
2678 + cb: (error?: Error) => void
2679 + ): T;
2680 + declare function pipeline<T: stream$Writable>(
2681 + s1: stream$Readable,
2682 + s2: stream$Duplex,
2683 + last: T,
2684 + cb: (error?: Error) => void
2685 + ): T;
2686 + declare function pipeline<T: stream$Writable>(
2687 + s1: stream$Readable,
2688 + s2: stream$Duplex,
2689 + s3: stream$Duplex,
2690 + last: T,
2691 + cb: (error?: Error) => void
2692 + ): T;
2693 + declare function pipeline<T: stream$Writable>(
2694 + s1: stream$Readable,
2695 + s2: stream$Duplex,
2696 + s3: stream$Duplex,
2697 + s4: stream$Duplex,
2698 + last: T,
2699 + cb: (error?: Error) => void
2700 + ): T;
2701 + declare function pipeline<T: stream$Writable>(
2702 + s1: stream$Readable,
2703 + s2: stream$Duplex,
2704 + s3: stream$Duplex,
2705 + s4: stream$Duplex,
2706 + s5: stream$Duplex,
2707 + last: T,
2708 + cb: (error?: Error) => void
2709 + ): T;
2710 + declare function pipeline<T: stream$Writable>(
2711 + s1: stream$Readable,
2712 + s2: stream$Duplex,
2713 + s3: stream$Duplex,
2714 + s4: stream$Duplex,
2715 + s5: stream$Duplex,
2716 + s6: stream$Duplex,
2717 + last: T,
2718 + cb: (error?: Error) => void
2719 + ): T;
2720 + declare function pipeline(
2721 + streams: Array<stream$Stream>,
2722 + cb: (error?: Error) => void
2723 + ): stream$Stream;
2724 +
2725 + declare interface StreamPipelineOptions {
2726 + +signal?: AbortSignal;
2727 + +end?: boolean;
2728 + }
2729 +
2730 + declare type StreamPromise = {
2731 + pipeline(
2732 + s1: stream$Readable,
2733 + last: stream$Writable,
2734 + options?: StreamPipelineOptions
2735 + ): Promise<void>,
2736 + pipeline(
2737 + s1: stream$Readable,
2738 + s2: stream$Duplex,
2739 + last: stream$Writable,
2740 + options?: StreamPipelineOptions
2741 + ): Promise<void>,
2742 + pipeline(
2743 + s1: stream$Readable,
2744 + s2: stream$Duplex,
2745 + s3: stream$Duplex,
2746 + last: stream$Writable,
2747 + options?: StreamPipelineOptions
2748 + ): Promise<void>,
2749 + pipeline(
2750 + s1: stream$Readable,
2751 + s2: stream$Duplex,
2752 + s3: stream$Duplex,
2753 + s4: stream$Duplex,
2754 + last: stream$Writable,
2755 + options?: StreamPipelineOptions
2756 + ): Promise<void>,
2757 + pipeline(
2758 + s1: stream$Readable,
2759 + s2: stream$Duplex,
2760 + s3: stream$Duplex,
2761 + s4: stream$Duplex,
2762 + s5: stream$Duplex,
2763 + last: stream$Writable,
2764 + options?: StreamPipelineOptions
2765 + ): Promise<void>,
2766 + pipeline(
2767 + s1: stream$Readable,
2768 + s2: stream$Duplex,
2769 + s3: stream$Duplex,
2770 + s4: stream$Duplex,
2771 + s5: stream$Duplex,
2772 + s6: stream$Duplex,
2773 + last: stream$Writable,
2774 + options?: StreamPipelineOptions
2775 + ): Promise<void>,
2776 + pipeline(
2777 + streams: $ReadOnlyArray<stream$Stream>,
2778 + options?: StreamPipelineOptions
2779 + ): Promise<void>,
2780 + ...
2781 + };
2782 +
2783 + declare var promises: StreamPromise;
2784 +}
2785 +
2786 +declare class tty$ReadStream extends net$Socket {
2787 + constructor(fd: number, options?: Object): void;
2788 + isRaw: boolean;
2789 + setRawMode(mode: boolean): void;
2790 + isTTY: true;
2791 +}
2792 +declare class tty$WriteStream extends net$Socket {
2793 + constructor(fd: number): void;
2794 + /**
2795 + * Clears the current line of this `WriteStream` in a direction identified by `dir`.
2796 + *
2797 + * TODO: takes a callback and returns `boolean` in v12+
2798 + */
2799 + clearLine(dir: -1 | 0 | 1): void;
2800 + columns: number;
2801 + /**
2802 + * Moves this WriteStream's cursor to the specified position
2803 + *
2804 + * TODO: takes a callback and returns `boolean` in v12+
2805 + */
2806 + cursorTo(x: number, y?: number): void;
2807 + isTTY: true;
2808 + /**
2809 + * Moves this WriteStream's cursor relative to its current position
2810 + *
2811 + * TODO: takes a callback and returns `boolean` in v12+
2812 + */
2813 + moveCursor(dx: number, dy: number): void;
2814 + rows: number;
2815 +
2816 + /**
2817 + * Clears this WriteStream from the current cursor down.
2818 + */
2819 + clearScreenDown(callback?: () => void): boolean;
2820 +
2821 + /**
2822 + * Use this to determine what colors the terminal supports. Due to the nature of colors in terminals it is possible to either have false positives or false negatives. It depends on process information and the environment variables that may lie about what terminal is used. It is possible to pass in an env object to simulate the usage of a specific terminal. This can be useful to check how specific environment settings behave.
2823 + * To enforce a specific color support, use one of the below environment settings.
2824 + *
2825 + * 2 colors: FORCE_COLOR = 0 (Disables colors)
2826 + * 16 colors: FORCE_COLOR = 1
2827 + * 256 colors: FORCE_COLOR = 2
2828 + * 16,777,216 colors: FORCE_COLOR = 3
2829 + * Disabling color support is also possible by using the NO_COLOR and NODE_DISABLE_COLORS environment variables.
2830 + */
2831 + getColorDepth(env?: typeof process.env):
2832 + | 1 // 2
2833 + | 4 // 16
2834 + | 8 // 256
2835 + | 24; // 16,777,216
2836 +
2837 + /**
2838 + * Returns the size of the TTY corresponding to this WriteStream. The array is of the type [numColumns, numRows] where numColumns and numRows represent the number of columns and rows in the corresponding TTY.
2839 + */
2840 + getWindowSize(): [
2841 + number, // columns
2842 + number, // rows
2843 + ];
2844 +
2845 + /**
2846 + * - count <integer> The number of colors that are requested (minimum 2). Default: 16.
2847 + * - env <Object> An object containing the environment variables to check. This enables simulating the usage of a specific terminal. Default: process.env.
2848 + * - Returns: <boolean>
2849 + *
2850 + * Returns true if the writeStream supports at least as many colors as provided in count. Minimum support is 2 (black and white).
2851 + *
2852 + * This has the same false positives and negatives as described in tty$WriteStream#getColorDepth().
2853 + */
2854 + hasColors(count?: number, env?: typeof process.env): boolean;
2855 +}
2856 +
2857 +declare module 'tty' {
2858 + declare function isatty(fd: number): boolean;
2859 + declare function setRawMode(mode: boolean): void;
2860 + declare var ReadStream: typeof tty$ReadStream;
2861 + declare var WriteStream: typeof tty$WriteStream;
2862 +}
2863 +
2864 +declare class string_decoder$StringDecoder {
2865 + constructor(encoding?: 'utf8' | 'ucs2' | 'utf16le' | 'base64'): void;
2866 + end(): string;
2867 + write(buffer: Buffer): string;
2868 +}
2869 +
2870 +declare module 'string_decoder' {
2871 + declare var StringDecoder: typeof string_decoder$StringDecoder;
2872 +}
2873 +
2874 +type tls$connectOptions = {
2875 + port?: number,
2876 + host?: string,
2877 + socket?: net$Socket,
2878 + rejectUnauthorized?: boolean,
2879 + path?: string,
2880 + lookup?: (
2881 + domain: string,
2882 + options?: ?number | ?Object,
2883 + callback?: (err: ?Error, address: string, family: number) => void
2884 + ) => mixed,
2885 + requestOCSP?: boolean,
2886 + ...
2887 +};
2888 +
2889 +type tls$Certificate$Subject = {
2890 + C?: string,
2891 + ST?: string,
2892 + L?: string,
2893 + O?: string,
2894 + OU?: string,
2895 + CN?: string,
2896 + ...
2897 +};
2898 +
2899 +type tls$Certificate = {
2900 + raw: Buffer,
2901 + subject: tls$Certificate$Subject,
2902 + issuer: tls$Certificate$Subject,
2903 + valid_from: string,
2904 + valid_to: string,
2905 + serialNumber: string,
2906 + fingerprint: string,
2907 + fingerprint256: string,
2908 + ext_key_usage?: Array<string>,
2909 + subjectaltname?: string,
2910 + infoAccess?: {[string]: Array<string>, ...},
2911 + issuerCertificate?: tls$Certificate,
2912 + ...
2913 +};
2914 +
2915 +declare class tls$TLSSocket extends net$Socket {
2916 + constructor(socket: net$Socket, options?: Object): void;
2917 + authorized: boolean;
2918 + authorizationError: string | null;
2919 + encrypted: true;
2920 + getCipher(): {
2921 + name: string,
2922 + version: string,
2923 + ...
2924 + } | null;
2925 + getEphemeralKeyInfo():
2926 + | {
2927 + type: 'DH',
2928 + size: number,
2929 + ...
2930 + }
2931 + | {
2932 + type: 'EDHC',
2933 + name: string,
2934 + size: number,
2935 + ...
2936 + }
2937 + | null;
2938 + getPeerCertificate(detailed?: boolean): tls$Certificate | null;
2939 + getSession(): ?Buffer;
2940 + getTLSTicket(): Buffer | void;
2941 + renegotiate(options: Object, callback: Function): boolean | void;
2942 + setMaxSendFragment(size: number): boolean;
2943 +}
2944 +
2945 +declare class tls$Server extends net$Server {
2946 + listen(
2947 + port?: number,
2948 + hostname?: string,
2949 + backlog?: number,
2950 + callback?: Function
2951 + ): tls$Server;
2952 + listen(path: string, callback?: Function): tls$Server;
2953 + listen(handle: Object, callback?: Function): tls$Server;
2954 + close(callback?: Function): tls$Server;
2955 + addContext(hostname: string, context: Object): void;
2956 + getTicketKeys(): Buffer;
2957 + setTicketKeys(keys: Buffer): void;
2958 +}
2959 +
2960 +declare module 'tls' {
2961 + declare var CLIENT_RENEG_LIMIT: number;
2962 + declare var CLIENT_RENEG_WINDOW: number;
2963 + declare var SLAB_BUFFER_SIZE: number;
2964 + declare var DEFAULT_CIPHERS: string;
2965 + declare var DEFAULT_ECDH_CURVE: string;
2966 + declare function getCiphers(): Array<string>;
2967 + declare function convertNPNProtocols(
2968 + NPNProtocols: Array<string>,
2969 + out: Object
2970 + ): void;
2971 + declare function checkServerIdentity(
2972 + servername: string,
2973 + cert: string
2974 + ): Error | void;
2975 + declare function parseCertString(s: string): Object;
2976 + declare function createSecureContext(details: Object): Object;
2977 + declare var SecureContext: Object;
2978 + declare var TLSSocket: typeof tls$TLSSocket;
2979 + declare var Server: typeof tls$Server;
2980 + declare function createServer(
2981 + options: Object,
2982 + secureConnectionListener?: Function
2983 + ): tls$Server;
2984 + declare function connect(
2985 + options: tls$connectOptions,
2986 + callback?: Function
2987 + ): tls$TLSSocket;
2988 + declare function connect(
2989 + port: number,
2990 + host?: string,
2991 + options?: tls$connectOptions,
2992 + callback?: Function
2993 + ): tls$TLSSocket;
2994 + declare function createSecurePair(
2995 + context?: Object,
2996 + isServer?: boolean,
2997 + requestCert?: boolean,
2998 + rejectUnauthorized?: boolean,
2999 + options?: Object
3000 + ): Object;
3001 +}
3002 +
3003 +type url$urlObject = {
3004 + +href?: string,
3005 + +protocol?: string | null,
3006 + +slashes?: boolean | null,
3007 + +auth?: string | null,
3008 + +hostname?: string | null,
3009 + +port?: string | number | null,
3010 + +host?: string | null,
3011 + +pathname?: string | null,
3012 + +search?: string | null,
3013 + +query?: Object | null,
3014 + +hash?: string | null,
3015 + ...
3016 +};
3017 +
3018 +declare module 'url' {
3019 + declare type Url = {|
3020 + protocol: string | null,
3021 + slashes: boolean | null,
3022 + auth: string | null,
3023 + host: string | null,
3024 + port: string | null,
3025 + hostname: string | null,
3026 + hash: string | null,
3027 + search: string | null,
3028 + query: string | null | {[string]: string, ...},
3029 + pathname: string | null,
3030 + path: string | null,
3031 + href: string,
3032 + |};
3033 +
3034 + declare type UrlWithStringQuery = {|
3035 + ...Url,
3036 + query: string | null,
3037 + |};
3038 +
3039 + declare type UrlWithParsedQuery = {|
3040 + ...Url,
3041 + query: {[string]: string, ...},
3042 + |};
3043 +
3044 + declare function parse(
3045 + urlStr: string,
3046 + parseQueryString: true,
3047 + slashesDenoteHost?: boolean
3048 + ): UrlWithParsedQuery;
3049 + declare function parse(
3050 + urlStr: string,
3051 + parseQueryString?: false | void,
3052 + slashesDenoteHost?: boolean
3053 + ): UrlWithStringQuery;
3054 + declare function parse(
3055 + urlStr: string,
3056 + parseQueryString?: boolean,
3057 + slashesDenoteHost?: boolean
3058 + ): Url;
3059 + declare function format(urlObj: url$urlObject): string;
3060 + declare function resolve(from: string, to: string): string;
3061 + declare function domainToASCII(domain: string): string;
3062 + declare function domainToUnicode(domain: string): string;
3063 + declare function pathToFileURL(path: string): url$urlObject;
3064 + declare function fileURLToPath(path: url$urlObject | string): string;
3065 + declare class URLSearchParams {
3066 + @@iterator(): Iterator<[string, string]>;
3067 +
3068 + size: number;
3069 +
3070 + constructor(
3071 + init?:
3072 + | string
3073 + | URLSearchParams
3074 + | Array<[string, string]>
3075 + | {[string]: string, ...}
3076 + ): void;
3077 + append(name: string, value: string): void;
3078 + delete(name: string, value?: void): void;
3079 + entries(): Iterator<[string, string]>;
3080 + forEach<This>(
3081 + callback: (
3082 + this: This,
3083 + value: string,
3084 + name: string,
3085 + searchParams: URLSearchParams
3086 + ) => mixed,
3087 + thisArg?: This
3088 + ): void;
3089 + get(name: string): string | null;
3090 + getAll(name: string): string[];
3091 + has(name: string, value?: string): boolean;
3092 + keys(): Iterator<string>;
3093 + set(name: string, value: string): void;
3094 + sort(): void;
3095 + values(): Iterator<string>;
3096 + toString(): string;
3097 + }
3098 + declare class URL {
3099 + static canParse(url: string, base?: string): boolean;
3100 + static createObjectURL(blob: Blob): string;
3101 + static createObjectURL(mediaSource: MediaSource): string;
3102 + static revokeObjectURL(url: string): void;
3103 + constructor(input: string, base?: string | URL): void;
3104 + hash: string;
3105 + host: string;
3106 + hostname: string;
3107 + href: string;
3108 + +origin: string;
3109 + password: string;
3110 + pathname: string;
3111 + port: string;
3112 + protocol: string;
3113 + search: string;
3114 + +searchParams: URLSearchParams;
3115 + username: string;
3116 + toString(): string;
3117 + toJSON(): string;
3118 + }
3119 +}
3120 +
3121 +type util$InspectOptions = {
3122 + showHidden?: boolean,
3123 + depth?: ?number,
3124 + colors?: boolean,
3125 + customInspect?: boolean,
3126 + ...
3127 +};
3128 +
3129 +declare type util$ParseArgsOption =
3130 + | {|
3131 + type: 'boolean',
3132 + multiple?: false,
3133 + short?: string,
3134 + default?: boolean,
3135 + |}
3136 + | {|
3137 + type: 'boolean',
3138 + multiple: true,
3139 + short?: string,
3140 + default?: Array<boolean>,
3141 + |}
3142 + | {|
3143 + type: 'string',
3144 + multiple?: false,
3145 + short?: string,
3146 + default?: string,
3147 + |}
3148 + | {|
3149 + type: 'string',
3150 + multiple: true,
3151 + short?: string,
3152 + default?: Array<string>,
3153 + |};
3154 +
3155 +type util$ParseArgsOptionToValue<TOption> = TOption['type'] extends 'boolean'
3156 + ? TOption['multiple'] extends true
3157 + ? Array<boolean>
3158 + : boolean
3159 + : TOption['type'] extends 'string'
3160 + ? TOption['multiple'] extends true
3161 + ? Array<string>
3162 + : string
3163 + : empty;
3164 +
3165 +type util$ParseArgsOptionsToValues<TOptions> = {
3166 + [key in keyof TOptions]: util$ParseArgsOptionToValue<{|
3167 + multiple: false,
3168 + ...TOptions[key],
3169 + |}>,
3170 +};
3171 +
3172 +type util$ParseArgsToken =
3173 + | {|
3174 + kind: 'option',
3175 + index: number,
3176 + name: string,
3177 + rawName: string,
3178 + value?: string,
3179 + inlineValue?: boolean,
3180 + |}
3181 + | {|
3182 + kind: 'positional',
3183 + index: number,
3184 + value: string,
3185 + |}
3186 + | {|
3187 + kind: 'option-terminator',
3188 + index: number,
3189 + |};
3190 +
3191 +declare module 'util' {
3192 + declare function debuglog(section: string): (data: any, ...args: any) => void;
3193 + declare function format(format: string, ...placeholders: any): string;
3194 + declare function log(string: string): void;
3195 + declare function inspect(object: any, options?: util$InspectOptions): string;
3196 + declare function isArray(object: any): boolean;
3197 + declare function isRegExp(object: any): boolean;
3198 + declare function isDate(object: any): boolean;
3199 + declare function isError(object: any): boolean;
3200 + declare function inherits(
3201 + constructor: Function,
3202 + superConstructor: Function
3203 + ): void;
3204 + declare function deprecate(f: Function, string: string): Function;
3205 + declare function promisify(f: Function): Function;
3206 + declare function callbackify(f: Function): Function;
3207 + declare function stripVTControlCharacters(str: string): string;
3208 +
3209 + declare function parseArgs<
3210 + TOptions: {[string]: util$ParseArgsOption} = {||},
3211 + >(config: {|
3212 + args?: Array<string>,
3213 + options?: TOptions,
3214 + strict?: boolean,
3215 + allowPositionals?: boolean,
3216 + tokens?: false,
3217 + |}): {|
3218 + values: util$ParseArgsOptionsToValues<TOptions>,
3219 + positionals: Array<string>,
3220 + |};
3221 +
3222 + declare function parseArgs<
3223 + TOptions: {[string]: util$ParseArgsOption} = {||},
3224 + >(config: {|
3225 + args?: Array<string>,
3226 + options?: TOptions,
3227 + strict?: boolean,
3228 + allowPositionals?: boolean,
3229 + tokens: true,
3230 + |}): {|
3231 + values: util$ParseArgsOptionsToValues<TOptions>,
3232 + positionals: Array<string>,
3233 + tokens: Array<util$ParseArgsToken>,
3234 + |};
3235 +
3236 + declare class TextDecoder {
3237 + constructor(
3238 + encoding?: string,
3239 + options: {
3240 + fatal?: boolean,
3241 + ignoreBOM?: boolean,
3242 + ...
3243 + }
3244 + ): void;
3245 + decode(
3246 + input?: ArrayBuffer | DataView | $TypedArray,
3247 + options?: {stream?: boolean, ...}
3248 + ): string;
3249 + encoding: string;
3250 + fatal: boolean;
3251 + ignoreBOM: boolean;
3252 + }
3253 +
3254 + declare class TextEncoder {
3255 + constructor(): void;
3256 + encode(input?: string): Uint8Array;
3257 + encoding: string;
3258 + }
3259 +
3260 + declare var types: {
3261 + isAnyArrayBuffer: (value: mixed) => boolean,
3262 + isArgumentsObject: (value: mixed) => boolean,
3263 + isArrayBuffer: (value: mixed) => boolean,
3264 + isAsyncFunction: (value: mixed) => boolean,
3265 + isBigInt64Array: (value: mixed) => boolean,
3266 + isBigUint64Array: (value: mixed) => boolean,
3267 + isBooleanObject: (value: mixed) => boolean,
3268 + isBoxedPrimitive: (value: mixed) => boolean,
3269 + isDataView: (value: mixed) => boolean,
3270 + isDate: (value: mixed) => boolean,
3271 + isExternal: (value: mixed) => boolean,
3272 + isFloat32Array: (value: mixed) => boolean,
3273 + isFloat64Array: (value: mixed) => boolean,
3274 + isGeneratorFunction: (value: mixed) => boolean,
3275 + isGeneratorObject: (value: mixed) => boolean,
3276 + isInt8Array: (value: mixed) => boolean,
3277 + isInt16Array: (value: mixed) => boolean,
3278 + isInt32Array: (value: mixed) => boolean,
3279 + isMap: (value: mixed) => boolean,
3280 + isMapIterator: (value: mixed) => boolean,
3281 + isModuleNamespaceObject: (value: mixed) => boolean,
3282 + isNativeError: (value: mixed) => boolean,
3283 + isNumberObject: (value: mixed) => boolean,
3284 + isPromise: (value: mixed) => boolean,
3285 + isProxy: (value: mixed) => boolean,
3286 + isRegExp: (value: mixed) => boolean,
3287 + isSet: (value: mixed) => boolean,
3288 + isSetIterator: (value: mixed) => boolean,
3289 + isSharedArrayBuffer: (value: mixed) => boolean,
3290 + isStringObject: (value: mixed) => boolean,
3291 + isSymbolObject: (value: mixed) => boolean,
3292 + isTypedArray: (value: mixed) => boolean,
3293 + isUint8Array: (value: mixed) => boolean,
3294 + isUint8ClampedArray: (value: mixed) => boolean,
3295 + isUint16Array: (value: mixed) => boolean,
3296 + isUint32Array: (value: mixed) => boolean,
3297 + isWeakMap: (value: mixed) => boolean,
3298 + isWeakSet: (value: mixed) => boolean,
3299 + isWebAssemblyCompiledModule: (value: mixed) => boolean,
3300 + ...
3301 + };
3302 +}
3303 +
3304 +type vm$ScriptOptions = {
3305 + cachedData?: Buffer,
3306 + columnOffset?: number,
3307 + displayErrors?: boolean,
3308 + filename?: string,
3309 + lineOffset?: number,
3310 + produceCachedData?: boolean,
3311 + timeout?: number,
3312 + ...
3313 +};
3314 +
3315 +type vm$CreateContextOptions = {
3316 + name?: string,
3317 + origin?: string,
3318 + codeGeneration?: {
3319 + strings?: boolean,
3320 + wasm?: boolean,
3321 + ...
3322 + },
3323 + ...
3324 +};
3325 +
3326 +type vm$CompileFunctionOptions = {
3327 + filename?: string,
3328 + lineOffset?: number,
3329 + columnOffset?: number,
3330 + cachedData?: Buffer,
3331 + produceCachedData?: boolean,
3332 + parsingContext?: {[key: string]: any, ...},
3333 + contextExtensions?: Array<{[key: string]: any, ...}>,
3334 + ...
3335 +};
3336 +
3337 +declare class vm$Script {
3338 + constructor(code: string, options?: vm$ScriptOptions | string): void;
3339 + cachedData: ?Buffer;
3340 + cachedDataRejected: ?boolean;
3341 + cachedDataProduced: ?boolean;
3342 + runInContext(
3343 + contextifiedSandbox: vm$Context,
3344 + options?: vm$ScriptOptions
3345 + ): any;
3346 + runInNewContext(
3347 + sandbox?: {[key: string]: any, ...},
3348 + options?: vm$ScriptOptions
3349 + ): any;
3350 + runInThisContext(options?: vm$ScriptOptions): any;
3351 + createCachedData(): Buffer;
3352 +}
3353 +
3354 +declare class vm$Context {}
3355 +
3356 +declare module 'vm' {
3357 + declare var Script: typeof vm$Script;
3358 + declare function createContext(
3359 + sandbox?: interface {[key: string]: any},
3360 + options?: vm$CreateContextOptions
3361 + ): vm$Context;
3362 + declare function isContext(sandbox: {[key: string]: any, ...}): boolean;
3363 + declare function runInContext(
3364 + code: string,
3365 + contextifiedSandbox: vm$Context,
3366 + options?: vm$ScriptOptions | string
3367 + ): any;
3368 + declare function runInDebugContext(code: string): any;
3369 + declare function runInNewContext(
3370 + code: string,
3371 + sandbox?: {[key: string]: any, ...},
3372 + options?: vm$ScriptOptions | string
3373 + ): any;
3374 + declare function runInThisContext(
3375 + code: string,
3376 + options?: vm$ScriptOptions | string
3377 + ): any;
3378 + declare function compileFunction(
3379 + code: string,
3380 + params: string[],
3381 + options: vm$CompileFunctionOptions
3382 + ): Function;
3383 +}
3384 +
3385 +type zlib$options = {
3386 + flush?: number,
3387 + chunkSize?: number,
3388 + windowBits?: number,
3389 + level?: number,
3390 + memLevel?: number,
3391 + strategy?: number,
3392 + dictionary?: Buffer,
3393 + ...
3394 +};
3395 +
3396 +type zlib$brotliOptions = {
3397 + flush?: number,
3398 + finishFlush?: number,
3399 + chunkSize?: number,
3400 + params?: {
3401 + [number]: boolean | number,
3402 + ...
3403 + },
3404 + maxOutputLength?: number,
3405 + ...
3406 +};
3407 +
3408 +type zlib$syncFn = (
3409 + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string,
3410 + options?: zlib$options
3411 +) => Buffer;
3412 +
3413 +type zlib$asyncFn = (
3414 + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string,
3415 + options?: zlib$options,
3416 + callback?: (error: ?Error, result: Buffer) => void
3417 +) => void;
3418 +
3419 +type zlib$brotliSyncFn = (
3420 + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string,
3421 + options?: zlib$brotliOptions
3422 +) => Buffer;
3423 +
3424 +type zlib$brotliAsyncFn = (
3425 + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string,
3426 + options?: zlib$brotliOptions,
3427 + callback?: (error: ?Error, result: Buffer) => void
3428 +) => void;
3429 +
3430 +// Accessing the constants directly from the module is currently still
3431 +// possible but should be considered deprecated.
3432 +// ref: https://github.com/nodejs/node/blob/master/doc/api/zlib.md
3433 +declare module 'zlib' {
3434 + declare var Z_NO_FLUSH: number;
3435 + declare var Z_PARTIAL_FLUSH: number;
3436 + declare var Z_SYNC_FLUSH: number;
3437 + declare var Z_FULL_FLUSH: number;
3438 + declare var Z_FINISH: number;
3439 + declare var Z_BLOCK: number;
3440 + declare var Z_TREES: number;
3441 + declare var Z_OK: number;
3442 + declare var Z_STREAM_END: number;
3443 + declare var Z_NEED_DICT: number;
3444 + declare var Z_ERRNO: number;
3445 + declare var Z_STREAM_ERROR: number;
3446 + declare var Z_DATA_ERROR: number;
3447 + declare var Z_MEM_ERROR: number;
3448 + declare var Z_BUF_ERROR: number;
3449 + declare var Z_VERSION_ERROR: number;
3450 + declare var Z_NO_COMPRESSION: number;
3451 + declare var Z_BEST_SPEED: number;
3452 + declare var Z_BEST_COMPRESSION: number;
3453 + declare var Z_DEFAULT_COMPRESSION: number;
3454 + declare var Z_FILTERED: number;
3455 + declare var Z_HUFFMAN_ONLY: number;
3456 + declare var Z_RLE: number;
3457 + declare var Z_FIXED: number;
3458 + declare var Z_DEFAULT_STRATEGY: number;
3459 + declare var Z_BINARY: number;
3460 + declare var Z_TEXT: number;
3461 + declare var Z_ASCII: number;
3462 + declare var Z_UNKNOWN: number;
3463 + declare var Z_DEFLATED: number;
3464 + declare var Z_NULL: number;
3465 + declare var Z_DEFAULT_CHUNK: number;
3466 + declare var Z_DEFAULT_LEVEL: number;
3467 + declare var Z_DEFAULT_MEMLEVEL: number;
3468 + declare var Z_DEFAULT_WINDOWBITS: number;
3469 + declare var Z_MAX_CHUNK: number;
3470 + declare var Z_MAX_LEVEL: number;
3471 + declare var Z_MAX_MEMLEVEL: number;
3472 + declare var Z_MAX_WINDOWBITS: number;
3473 + declare var Z_MIN_CHUNK: number;
3474 + declare var Z_MIN_LEVEL: number;
3475 + declare var Z_MIN_MEMLEVEL: number;
3476 + declare var Z_MIN_WINDOWBITS: number;
3477 + declare var constants: {
3478 + Z_NO_FLUSH: number,
3479 + Z_PARTIAL_FLUSH: number,
3480 + Z_SYNC_FLUSH: number,
3481 + Z_FULL_FLUSH: number,
3482 + Z_FINISH: number,
3483 + Z_BLOCK: number,
3484 + Z_TREES: number,
3485 + Z_OK: number,
3486 + Z_STREAM_END: number,
3487 + Z_NEED_DICT: number,
3488 + Z_ERRNO: number,
3489 + Z_STREAM_ERROR: number,
3490 + Z_DATA_ERROR: number,
3491 + Z_MEM_ERROR: number,
3492 + Z_BUF_ERROR: number,
3493 + Z_VERSION_ERROR: number,
3494 + Z_NO_COMPRESSION: number,
3495 + Z_BEST_SPEED: number,
3496 + Z_BEST_COMPRESSION: number,
3497 + Z_DEFAULT_COMPRESSION: number,
3498 + Z_FILTERED: number,
3499 + Z_HUFFMAN_ONLY: number,
3500 + Z_RLE: number,
3501 + Z_FIXED: number,
3502 + Z_DEFAULT_STRATEGY: number,
3503 + Z_BINARY: number,
3504 + Z_TEXT: number,
3505 + Z_ASCII: number,
3506 + Z_UNKNOWN: number,
3507 + Z_DEFLATED: number,
3508 + Z_NULL: number,
3509 + Z_DEFAULT_CHUNK: number,
3510 + Z_DEFAULT_LEVEL: number,
3511 + Z_DEFAULT_MEMLEVEL: number,
3512 + Z_DEFAULT_WINDOWBITS: number,
3513 + Z_MAX_CHUNK: number,
3514 + Z_MAX_LEVEL: number,
3515 + Z_MAX_MEMLEVEL: number,
3516 + Z_MAX_WINDOWBITS: number,
3517 + Z_MIN_CHUNK: number,
3518 + Z_MIN_LEVEL: number,
3519 + Z_MIN_MEMLEVEL: number,
3520 + Z_MIN_WINDOWBITS: number,
3521 +
3522 + BROTLI_DECODE: number,
3523 + BROTLI_ENCODE: number,
3524 + BROTLI_OPERATION_PROCESS: number,
3525 + BROTLI_OPERATION_FLUSH: number,
3526 + BROTLI_OPERATION_FINISH: number,
3527 + BROTLI_OPERATION_EMIT_METADATA: number,
3528 + BROTLI_PARAM_MODE: number,
3529 + BROTLI_MODE_GENERIC: number,
3530 + BROTLI_MODE_TEXT: number,
3531 + BROTLI_MODE_FONT: number,
3532 + BROTLI_DEFAULT_MODE: number,
3533 + BROTLI_PARAM_QUALITY: number,
3534 + BROTLI_MIN_QUALITY: number,
3535 + BROTLI_MAX_QUALITY: number,
3536 + BROTLI_DEFAULT_QUALITY: number,
3537 + BROTLI_PARAM_LGWIN: number,
3538 + BROTLI_MIN_WINDOW_BITS: number,
3539 + BROTLI_MAX_WINDOW_BITS: number,
3540 + BROTLI_LARGE_MAX_WINDOW_BITS: number,
3541 + BROTLI_DEFAULT_WINDOW: number,
3542 + BROTLI_PARAM_LGBLOCK: number,
3543 + BROTLI_MIN_INPUT_BLOCK_BITS: number,
3544 + BROTLI_MAX_INPUT_BLOCK_BITS: number,
3545 + BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number,
3546 + BROTLI_PARAM_SIZE_HINT: number,
3547 + BROTLI_PARAM_LARGE_WINDOW: number,
3548 + BROTLI_PARAM_NPOSTFIX: number,
3549 + BROTLI_PARAM_NDIRECT: number,
3550 + BROTLI_DECODER_RESULT_ERROR: number,
3551 + BROTLI_DECODER_RESULT_SUCCESS: number,
3552 + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number,
3553 + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number,
3554 + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number,
3555 + BROTLI_DECODER_PARAM_LARGE_WINDOW: number,
3556 + BROTLI_DECODER_NO_ERROR: number,
3557 + BROTLI_DECODER_SUCCESS: number,
3558 + BROTLI_DECODER_NEEDS_MORE_INPUT: number,
3559 + BROTLI_DECODER_NEEDS_MORE_OUTPUT: number,
3560 + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number,
3561 + BROTLI_DECODER_ERROR_FORMAT_RESERVED: number,
3562 + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number,
3563 + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number,
3564 + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number,
3565 + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number,
3566 + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number,
3567 + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number,
3568 + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number,
3569 + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number,
3570 + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number,
3571 + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number,
3572 + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number,
3573 + BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number,
3574 + BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number,
3575 + BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number,
3576 + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number,
3577 + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number,
3578 + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number,
3579 + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number,
3580 + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number,
3581 + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number,
3582 + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number,
3583 + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number,
3584 + BROTLI_DECODER_ERROR_UNREACHABL: number,
3585 + ...
3586 + };
3587 + declare var codes: {
3588 + Z_OK: number,
3589 + Z_STREAM_END: number,
3590 + Z_NEED_DICT: number,
3591 + Z_ERRNO: number,
3592 + Z_STREAM_ERROR: number,
3593 + Z_DATA_ERROR: number,
3594 + Z_MEM_ERROR: number,
3595 + Z_BUF_ERROR: number,
3596 + Z_VERSION_ERROR: number,
3597 + ...
3598 + };
3599 + declare class Zlib extends stream$Duplex {
3600 + // TODO
3601 + }
3602 + declare class BrotliCompress extends Zlib {}
3603 + declare class BrotliDecompress extends Zlib {}
3604 + declare class Deflate extends Zlib {}
3605 + declare class Inflate extends Zlib {}
3606 + declare class Gzip extends Zlib {}
3607 + declare class Gunzip extends Zlib {}
3608 + declare class DeflateRaw extends Zlib {}
3609 + declare class InflateRaw extends Zlib {}
3610 + declare class Unzip extends Zlib {}
3611 + declare function createBrotliCompress(
3612 + options?: zlib$brotliOptions
3613 + ): BrotliCompress;
3614 + declare function createBrotliDecompress(
3615 + options?: zlib$brotliOptions
3616 + ): BrotliDecompress;
3617 + declare function createDeflate(options?: zlib$options): Deflate;
3618 + declare function createInflate(options?: zlib$options): Inflate;
3619 + declare function createDeflateRaw(options?: zlib$options): DeflateRaw;
3620 + declare function createInflateRaw(options?: zlib$options): InflateRaw;
3621 + declare function createGzip(options?: zlib$options): Gzip;
3622 + declare function createGunzip(options?: zlib$options): Gunzip;
3623 + declare function createUnzip(options?: zlib$options): Unzip;
3624 + declare var brotliCompress: zlib$brotliAsyncFn;
3625 + declare var brotliCompressSync: zlib$brotliSyncFn;
3626 + declare var brotliDeompress: zlib$brotliAsyncFn;
3627 + declare var brotliDecompressSync: zlib$brotliSyncFn;
3628 + declare var deflate: zlib$asyncFn;
3629 + declare var deflateSync: zlib$syncFn;
3630 + declare var gzip: zlib$asyncFn;
3631 + declare var gzipSync: zlib$syncFn;
3632 + declare var deflateRaw: zlib$asyncFn;
3633 + declare var deflateRawSync: zlib$syncFn;
3634 + declare var unzip: zlib$asyncFn;
3635 + declare var unzipSync: zlib$syncFn;
3636 + declare var inflate: zlib$asyncFn;
3637 + declare var inflateSync: zlib$syncFn;
3638 + declare var gunzip: zlib$asyncFn;
3639 + declare var gunzipSync: zlib$syncFn;
3640 + declare var inflateRaw: zlib$asyncFn;
3641 + declare var inflateRawSync: zlib$syncFn;
3642 +}
3643 +
3644 +declare module 'assert' {
3645 + declare class AssertionError extends Error {}
3646 + declare type AssertStrict = {
3647 + (value: any, message?: string): void,
3648 + ok(value: any, message?: string): void,
3649 + fail(message?: string | Error): void,
3650 + // deprecated since v10.15
3651 + fail(actual: any, expected: any, message: string, operator: string): void,
3652 + equal(actual: any, expected: any, message?: string): void,
3653 + notEqual(actual: any, expected: any, message?: string): void,
3654 + deepEqual(actual: any, expected: any, message?: string): void,
3655 + notDeepEqual(actual: any, expected: any, message?: string): void,
3656 + throws(
3657 + block: Function,
3658 + error?: Function | RegExp | ((err: any) => boolean),
3659 + message?: string
3660 + ): void,
3661 + doesNotThrow(block: Function, message?: string): void,
3662 + ifError(value: any): void,
3663 + AssertionError: typeof AssertionError,
3664 + strict: AssertStrict,
3665 + ...
3666 + };
3667 + declare module.exports: {
3668 + (value: any, message?: string): void,
3669 + ok(value: any, message?: string): void,
3670 + fail(message?: string | Error): void,
3671 + // deprecated since v10.15
3672 + fail(actual: any, expected: any, message: string, operator: string): void,
3673 + equal(actual: any, expected: any, message?: string): void,
3674 + notEqual(actual: any, expected: any, message?: string): void,
3675 + deepEqual(actual: any, expected: any, message?: string): void,
3676 + notDeepEqual(actual: any, expected: any, message?: string): void,
3677 + strictEqual(actual: any, expected: any, message?: string): void,
3678 + notStrictEqual(actual: any, expected: any, message?: string): void,
3679 + deepStrictEqual(actual: any, expected: any, message?: string): void,
3680 + notDeepStrictEqual(actual: any, expected: any, message?: string): void,
3681 + throws(
3682 + block: Function,
3683 + error?: Function | RegExp | ((err: any) => boolean),
3684 + message?: string
3685 + ): void,
3686 + doesNotThrow(block: Function, message?: string): void,
3687 + ifError(value: any): void,
3688 + AssertionError: typeof AssertionError,
3689 + strict: AssertStrict,
3690 + ...
3691 + };
3692 +}
3693 +
3694 +type HeapCodeStatistics = {
3695 + code_and_metadata_size: number,
3696 + bytecode_and_metadata_size: number,
3697 + external_script_source_size: number,
3698 + ...
3699 +};
3700 +
3701 +type HeapStatistics = {
3702 + total_heap_size: number,
3703 + total_heap_size_executable: number,
3704 + total_physical_size: number,
3705 + total_available_size: number,
3706 + used_heap_size: number,
3707 + heap_size_limit: number,
3708 + malloced_memory: number,
3709 + peak_malloced_memory: number,
3710 + does_zap_garbage: 0 | 1,
3711 + number_of_native_contexts: number,
3712 + number_of_detached_contexts: number,
3713 + ...
3714 +};
3715 +
3716 +type HeapSpaceStatistics = {
3717 + space_name: string,
3718 + space_size: number,
3719 + space_used_size: number,
3720 + space_available_size: number,
3721 + physical_space_size: number,
3722 + ...
3723 +};
3724 +
3725 +// Adapted from DefinitelyTyped for Node v14:
3726 +// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/dea4d99dc302a0b0a25270e46e72c1fe9b741a17/types/node/v14/v8.d.ts
3727 +declare module 'v8' {
3728 + /**
3729 + * Returns an integer representing a "version tag" derived from the V8 version, command line flags and detected CPU features.
3730 + * This is useful for determining whether a vm.Script cachedData buffer is compatible with this instance of V8.
3731 + */
3732 + declare function cachedDataVersionTag(): number;
3733 +
3734 + /**
3735 + * Generates a snapshot of the current V8 heap and returns a Readable
3736 + * Stream that may be used to read the JSON serialized representation.
3737 + * This conversation was marked as resolved by joyeecheung
3738 + * This JSON stream format is intended to be used with tools such as
3739 + * Chrome DevTools. The JSON schema is undocumented and specific to the
3740 + * V8 engine, and may change from one version of V8 to the next.
3741 + */
3742 + declare function getHeapSnapshot(): stream$Readable;
3743 +
3744 + /**
3745 + *
3746 + * @param fileName The file path where the V8 heap snapshot is to be
3747 + * saved. If not specified, a file name with the pattern
3748 + * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
3749 + * generated, where `{pid}` will be the PID of the Node.js process,
3750 + * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
3751 + * the main Node.js thread or the id of a worker thread.
3752 + */
3753 + declare function writeHeapSnapshot(fileName?: string): string;
3754 +
3755 + declare function getHeapCodeStatistics(): HeapCodeStatistics;
3756 +
3757 + declare function getHeapStatistics(): HeapStatistics;
3758 + declare function getHeapSpaceStatistics(): Array<HeapSpaceStatistics>;
3759 + declare function setFlagsFromString(flags: string): void;
3760 +
3761 + declare class Serializer {
3762 + constructor(): void;
3763 +
3764 + /**
3765 + * Writes out a header, which includes the serialization format version.
3766 + */
3767 + writeHeader(): void;
3768 +
3769 + /**
3770 + * Serializes a JavaScript value and adds the serialized representation to the internal buffer.
3771 + * This throws an error if value cannot be serialized.
3772 + */
3773 + writeValue(val: any): boolean;
3774 +
3775 + /**
3776 + * Returns the stored internal buffer.
3777 + * This serializer should not be used once the buffer is released.
3778 + * Calling this method results in undefined behavior if a previous write has failed.
3779 + */
3780 + releaseBuffer(): Buffer;
3781 +
3782 + /**
3783 + * Marks an ArrayBuffer as having its contents transferred out of band.\
3784 + * Pass the corresponding ArrayBuffer in the deserializing context to deserializer.transferArrayBuffer().
3785 + */
3786 + transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
3787 +
3788 + /**
3789 + * Write a raw 32-bit unsigned integer.
3790 + */
3791 + writeUint32(value: number): void;
3792 +
3793 + /**
3794 + * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
3795 + */
3796 + writeUint64(hi: number, lo: number): void;
3797 +
3798 + /**
3799 + * Write a JS number value.
3800 + */
3801 + writeDouble(value: number): void;
3802 +
3803 + /**
3804 + * Write raw bytes into the serializer’s internal buffer.
3805 + * The deserializer will require a way to compute the length of the buffer.
3806 + */
3807 + writeRawBytes(buffer: Buffer | $TypedArray | DataView): void;
3808 + }
3809 +
3810 + /**
3811 + * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
3812 + * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
3813 + */
3814 + declare class DefaultSerializer extends Serializer {}
3815 +
3816 + declare class Deserializer {
3817 + constructor(data: Buffer | $TypedArray | DataView): void;
3818 +
3819 + /**
3820 + * Reads and validates a header (including the format version).
3821 + * May, for example, reject an invalid or unsupported wire format.
3822 + * In that case, an Error is thrown.
3823 + */
3824 + readHeader(): boolean;
3825 +
3826 + /**
3827 + * Deserializes a JavaScript value from the buffer and returns it.
3828 + */
3829 + readValue(): any;
3830 +
3831 + /**
3832 + * Marks an ArrayBuffer as having its contents transferred out of band.
3833 + * Pass the corresponding `ArrayBuffer` in the serializing context to serializer.transferArrayBuffer()
3834 + * (or return the id from serializer._getSharedArrayBufferId() in the case of SharedArrayBuffers).
3835 + */
3836 + transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
3837 +
3838 + /**
3839 + * Reads the underlying wire format version.
3840 + * Likely mostly to be useful to legacy code reading old wire format versions.
3841 + * May not be called before .readHeader().
3842 + */
3843 + getWireFormatVersion(): number;
3844 +
3845 + /**
3846 + * Read a raw 32-bit unsigned integer and return it.
3847 + */
3848 + readUint32(): number;
3849 +
3850 + /**
3851 + * Read a raw 64-bit unsigned integer and return it as an array [hi, lo] with two 32-bit unsigned integer entries.
3852 + */
3853 + readUint64(): [number, number];
3854 +
3855 + /**
3856 + * Read a JS number value.
3857 + */
3858 + readDouble(): number;
3859 +
3860 + /**
3861 + * Read raw bytes from the deserializer’s internal buffer.
3862 + * The length parameter must correspond to the length of the buffer that was passed to serializer.writeRawBytes().
3863 + */
3864 + readRawBytes(length: number): Buffer;
3865 + }
3866 +
3867 + /**
3868 + * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
3869 + * and only stores the part of their underlying `ArrayBuffers` that they are referring to.
3870 + */
3871 + declare class DefaultDeserializer extends Deserializer {}
3872 +
3873 + /**
3874 + * Uses a `DefaultSerializer` to serialize value into a buffer.
3875 + */
3876 + declare function serialize(value: any): Buffer;
3877 +
3878 + /**
3879 + * Uses a `DefaultDeserializer` with default options to read a JS value from a buffer.
3880 + */
3881 + declare function deserialize(data: Buffer | $TypedArray | DataView): any;
3882 +}
3883 +
3884 +type repl$DefineCommandOptions = (...args: Array<any>) => void | {
3885 + action: (...args: Array<any>) => void,
3886 + help?: string,
3887 + ...
3888 +};
3889 +
3890 +declare class $SymbolReplModeMagic mixins Symbol {}
3891 +declare class $SymbolReplModeSloppy mixins Symbol {}
3892 +declare class $SymbolReplModeStrict mixins Symbol {}
3893 +
3894 +declare module 'repl' {
3895 + declare var REPL_MODE_MAGIC: $SymbolReplModeMagic;
3896 + declare var REPL_MODE_SLOPPY: $SymbolReplModeSloppy;
3897 + declare var REPL_MODE_STRICT: $SymbolReplModeStrict;
3898 +
3899 + declare class REPLServer extends readline$Interface {
3900 + context: vm$Context;
3901 + defineCommand(command: string, options: repl$DefineCommandOptions): void;
3902 + displayPrompt(preserveCursor?: boolean): void;
3903 + }
3904 +
3905 + declare function start(prompt: string): REPLServer;
3906 + declare function start(options: {
3907 + prompt?: string,
3908 + input?: stream$Readable,
3909 + output?: stream$Writable,
3910 + terminal?: boolean,
3911 + eval?: Function,
3912 + useColors?: boolean,
3913 + useGlobal?: boolean,
3914 + ignoreUndefined?: boolean,
3915 + writer?: (object: any, options?: util$InspectOptions) => string,
3916 + completer?: readline$InterfaceCompleter,
3917 + replMode?:
3918 + | $SymbolReplModeMagic
3919 + | $SymbolReplModeSloppy
3920 + | $SymbolReplModeStrict,
3921 + breakEvalOnSigint?: boolean,
3922 + ...
3923 + }): REPLServer;
3924 +
3925 + declare class Recoverable extends SyntaxError {
3926 + constructor(err: Error): void;
3927 + }
3928 +}
3929 +
3930 +declare module 'inspector' {
3931 + declare function open(port?: number, host?: string, wait?: boolean): void;
3932 +
3933 + declare function close(): void;
3934 + declare function url(): string | void;
3935 + declare var console: Object;
3936 + declare function waitForDebugger(): void;
3937 +
3938 + declare class Session extends events$EventEmitter {
3939 + constructor(): void;
3940 + connect(): void;
3941 + connectToMainThread(): void;
3942 + disconnect(): void;
3943 + post(method: string, params?: Object, callback?: Function): void;
3944 + }
3945 +}
3946 +
3947 +/* globals: https://nodejs.org/api/globals.html */
3948 +
3949 +type process$CPUUsage = {
3950 + user: number,
3951 + system: number,
3952 + ...
3953 +};
3954 +
3955 +declare class Process extends events$EventEmitter {
3956 + abort(): void;
3957 + allowedNodeEnvironmentFlags: Set<string>;
3958 + arch: string;
3959 + argv: Array<string>;
3960 + chdir(directory: string): void;
3961 + config: Object;
3962 + connected: boolean;
3963 + cpuUsage(previousValue?: process$CPUUsage): process$CPUUsage;
3964 + cwd(): string;
3965 + disconnect?: () => void;
3966 + domain?: domain$Domain;
3967 + env: {[key: string]: string | void, ...};
3968 + emitWarning(warning: string | Error): void;
3969 + emitWarning(
3970 + warning: string,
3971 + typeOrCtor: string | ((...empty) => mixed)
3972 + ): void;
3973 + emitWarning(
3974 + warning: string,
3975 + type: string,
3976 + codeOrCtor: string | ((...empty) => mixed)
3977 + ): void;
3978 + emitWarning(
3979 + warning: string,
3980 + type: string,
3981 + code: string,
3982 + ctor?: (...empty) => mixed
3983 + ): void;
3984 + execArgv: Array<string>;
3985 + execPath: string;
3986 + exit(code?: number): empty;
3987 + exitCode?: number;
3988 + getegid?: () => number;
3989 + geteuid?: () => number;
3990 + getgid?: () => number;
3991 + getgroups?: () => Array<number>;
3992 + getuid?: () => number;
3993 + hrtime: {
3994 + (time?: [number, number]): [number, number],
3995 + bigint: () => bigint,
3996 + ...
3997 + };
3998 + initgroups?: (user: number | string, extra_group: number | string) => void;
3999 + kill(pid: number, signal?: string | number): void;
4000 + mainModule: Object;
4001 + memoryUsage(): {
4002 + arrayBuffers: number,
4003 + rss: number,
4004 + heapTotal: number,
4005 + heapUsed: number,
4006 + external: number,
4007 + ...
4008 + };
4009 + nextTick: <T>(cb: (...T) => mixed, ...T) => void;
4010 + pid: number;
4011 + platform: string;
4012 + release: {
4013 + name: string,
4014 + lts?: string,
4015 + sourceUrl: string,
4016 + headersUrl: string,
4017 + libUrl: string,
4018 + ...
4019 + };
4020 + send?: (
4021 + message: any,
4022 + sendHandleOrCallback?: net$Socket | net$Server | Function,
4023 + callback?: Function
4024 + ) => void;
4025 + setegid?: (id: number | string) => void;
4026 + seteuid?: (id: number | string) => void;
4027 + setgid?: (id: number | string) => void;
4028 + setgroups?: <Group: string | number>(groups: Array<Group>) => void;
4029 + setuid?: (id: number | string) => void;
4030 + stderr: stream$Writable | tty$WriteStream;
4031 + stdin: stream$Readable | tty$ReadStream;
4032 + stdout: stream$Writable | tty$WriteStream;
4033 + title: string;
4034 + umask(mask?: number): number;
4035 + uptime(): number;
4036 + version: string;
4037 + versions: {
4038 + [key: string]: ?string,
4039 + node: string,
4040 + v8: string,
4041 + ...
4042 + };
4043 +}
4044 +declare var process: Process;
4045 +
4046 +declare var __filename: string;
4047 +declare var __dirname: string;
4048 +
4049 +declare function setImmediate(
4050 + callback: (...args: Array<any>) => mixed,
4051 + ...args: Array<any>
4052 +): Object;
4053 +declare function clearImmediate(immediateObject: any): Object;
4054 +
4055 +// https://nodejs.org/api/esm.html#node-imports
4056 +
4057 +declare module 'node:assert' {
4058 + declare module.exports: $Exports<'assert'>;
4059 +}
4060 +
4061 +declare module 'node:assert/strict' {
4062 + declare module.exports: $Exports<'assert'>['strict'];
4063 +}
4064 +
4065 +declare module 'node:events' {
4066 + declare module.exports: $Exports<'events'>;
4067 +}
4068 +
4069 +declare module 'node:fs' {
4070 + declare module.exports: $Exports<'fs'>;
4071 +}
4072 +
4073 +declare module 'node:os' {
4074 + declare module.exports: $Exports<'os'>;
4075 +}
4076 +
4077 +declare module 'fs/promises' {
4078 + declare module.exports: $Exports<'fs'>['promises'];
4079 +}
4080 +
4081 +declare module 'node:fs/promises' {
4082 + declare module.exports: $Exports<'fs'>['promises'];
4083 +}
4084 +
4085 +declare module 'node:path' {
4086 + declare module.exports: $Exports<'path'>;
4087 +}
4088 +
4089 +declare module 'process' {
4090 + declare module.exports: Process;
4091 +}
4092 +
4093 +declare module 'node:process' {
4094 + declare module.exports: $Exports<'process'>;
4095 +}
4096 +
4097 +declare module 'node:util' {
4098 + declare module.exports: $Exports<'util'>;
4099 +}
4100 +
4101 +declare module 'node:url' {
4102 + declare module.exports: $Exports<'url'>;
4103 +}
4104 +
4105 +declare module 'worker_threads' {
4106 + declare var isMainThread: boolean;
4107 + declare var parentPort: null | MessagePort;
4108 + declare var threadId: number;
4109 + declare var workerData: any;
4110 +
4111 + declare class MessageChannel {
4112 + +port1: MessagePort;
4113 + +port2: MessagePort;
4114 + }
4115 +
4116 + declare class MessagePort extends events$EventEmitter {
4117 + close(): void;
4118 + postMessage(
4119 + value: any,
4120 + transferList?: Array<ArrayBuffer | MessagePort>
4121 + ): void;
4122 + ref(): void;
4123 + unref(): void;
4124 + start(): void;
4125 +
4126 + addListener(event: 'close', listener: () => void): this;
4127 + addListener(event: 'message', listener: (value: any) => void): this;
4128 + addListener(
4129 + event: string | Symbol,
4130 + listener: (...args: any[]) => void
4131 + ): this;
4132 +
4133 + emit(event: 'close'): boolean;
4134 + emit(event: 'message', value: any): boolean;
4135 + emit(event: string | Symbol, ...args: any[]): boolean;
4136 +
4137 + on(event: 'close', listener: () => void): this;
4138 + on(event: 'message', listener: (value: any) => void): this;
4139 + on(event: string | Symbol, listener: (...args: any[]) => void): this;
4140 +
4141 + once(event: 'close', listener: () => void): this;
4142 + once(event: 'message', listener: (value: any) => void): this;
4143 + once(event: string | Symbol, listener: (...args: any[]) => void): this;
4144 +
4145 + prependListener(event: 'close', listener: () => void): this;
4146 + prependListener(event: 'message', listener: (value: any) => void): this;
4147 + prependListener(
4148 + event: string | Symbol,
4149 + listener: (...args: any[]) => void
4150 + ): this;
4151 +
4152 + prependOnceListener(event: 'close', listener: () => void): this;
4153 + prependOnceListener(event: 'message', listener: (value: any) => void): this;
4154 + prependOnceListener(
4155 + event: string | Symbol,
4156 + listener: (...args: any[]) => void
4157 + ): this;
4158 +
4159 + removeListener(event: 'close', listener: () => void): this;
4160 + removeListener(event: 'message', listener: (value: any) => void): this;
4161 + removeListener(
4162 + event: string | Symbol,
4163 + listener: (...args: any[]) => void
4164 + ): this;
4165 +
4166 + off(event: 'close', listener: () => void): this;
4167 + off(event: 'message', listener: (value: any) => void): this;
4168 + off(event: string | Symbol, listener: (...args: any[]) => void): this;
4169 + }
4170 +
4171 + declare type WorkerOptions = {|
4172 + env?: Object,
4173 + eval?: boolean,
4174 + workerData?: any,
4175 + stdin?: boolean,
4176 + stdout?: boolean,
4177 + stderr?: boolean,
4178 + execArgv?: string[],
4179 + |};
4180 +
4181 + declare class Worker extends events$EventEmitter {
4182 + +stdin: stream$Writable | null;
4183 + +stdout: stream$Readable;
4184 + +stderr: stream$Readable;
4185 + +threadId: number;
4186 +
4187 + constructor(filename: string, options?: WorkerOptions): void;
4188 +
4189 + postMessage(
4190 + value: any,
4191 + transferList?: Array<ArrayBuffer | MessagePort>
4192 + ): void;
4193 + ref(): void;
4194 + unref(): void;
4195 + terminate(callback?: (err: Error, exitCode: number) => void): void;
4196 + /**
4197 + * Transfer a `MessagePort` to a different `vm` Context. The original `port`
4198 + * object will be rendered unusable, and the returned `MessagePort` instance will
4199 + * take its place.
4200 + *
4201 + * The returned `MessagePort` will be an object in the target context, and will
4202 + * inherit from its global `Object` class. Objects passed to the
4203 + * `port.onmessage()` listener will also be created in the target context
4204 + * and inherit from its global `Object` class.
4205 + *
4206 + * However, the created `MessagePort` will no longer inherit from
4207 + * `EventEmitter`, and only `port.onmessage()` can be used to receive
4208 + * events using it.
4209 + */
4210 + moveMessagePortToContext(
4211 + port: MessagePort,
4212 + context: vm$Context
4213 + ): MessagePort;
4214 +
4215 + addListener(event: 'error', listener: (err: Error) => void): this;
4216 + addListener(event: 'exit', listener: (exitCode: number) => void): this;
4217 + addListener(event: 'message', listener: (value: any) => void): this;
4218 + addListener(event: 'online', listener: () => void): this;
4219 + addListener(
4220 + event: string | Symbol,
4221 + listener: (...args: any[]) => void
4222 + ): this;
4223 +
4224 + emit(event: 'error', err: Error): boolean;
4225 + emit(event: 'exit', exitCode: number): boolean;
4226 + emit(event: 'message', value: any): boolean;
4227 + emit(event: 'online'): boolean;
4228 + emit(event: string | Symbol, ...args: any[]): boolean;
4229 +
4230 + on(event: 'error', listener: (err: Error) => void): this;
4231 + on(event: 'exit', listener: (exitCode: number) => void): this;
4232 + on(event: 'message', listener: (value: any) => void): this;
4233 + on(event: 'online', listener: () => void): this;
4234 + on(event: string | Symbol, listener: (...args: any[]) => void): this;
4235 +
4236 + once(event: 'error', listener: (err: Error) => void): this;
4237 + once(event: 'exit', listener: (exitCode: number) => void): this;
4238 + once(event: 'message', listener: (value: any) => void): this;
4239 + once(event: 'online', listener: () => void): this;
4240 + once(event: string | Symbol, listener: (...args: any[]) => void): this;
4241 +
4242 + prependListener(event: 'error', listener: (err: Error) => void): this;
4243 + prependListener(event: 'exit', listener: (exitCode: number) => void): this;
4244 + prependListener(event: 'message', listener: (value: any) => void): this;
4245 + prependListener(event: 'online', listener: () => void): this;
4246 + prependListener(
4247 + event: string | Symbol,
4248 + listener: (...args: any[]) => void
4249 + ): this;
4250 +
4251 + prependOnceListener(event: 'error', listener: (err: Error) => void): this;
4252 + prependOnceListener(
4253 + event: 'exit',
4254 + listener: (exitCode: number) => void
4255 + ): this;
4256 + prependOnceListener(event: 'message', listener: (value: any) => void): this;
4257 + prependOnceListener(event: 'online', listener: () => void): this;
4258 + prependOnceListener(
4259 + event: string | Symbol,
4260 + listener: (...args: any[]) => void
4261 + ): this;
4262 +
4263 + removeListener(event: 'error', listener: (err: Error) => void): this;
4264 + removeListener(event: 'exit', listener: (exitCode: number) => void): this;
4265 + removeListener(event: 'message', listener: (value: any) => void): this;
4266 + removeListener(event: 'online', listener: () => void): this;
4267 + removeListener(
4268 + event: string | Symbol,
4269 + listener: (...args: any[]) => void
4270 + ): this;
4271 +
4272 + off(event: 'error', listener: (err: Error) => void): this;
4273 + off(event: 'exit', listener: (exitCode: number) => void): this;
4274 + off(event: 'message', listener: (value: any) => void): this;
4275 + off(event: 'online', listener: () => void): this;
4276 + off(event: string | Symbol, listener: (...args: any[]) => void): this;
4277 + }
4278 +}
4279 +
4280 +declare module 'node:worker_threads' {
4281 + declare module.exports: $Exports<'worker_threads'>;
4282 +}
flow-typed/environments/serviceworkers.js new
+248
@@ -0,0 +1,248 @@
1 +// flow-typed signature: f6bda44505d6258bae702a65ee2878f2
2 +// flow-typed version: 840509ea9d/serviceworkers/flow_>=v0.261.x
3 +
4 +type FrameType = 'auxiliary' | 'top-level' | 'nested' | 'none';
5 +type VisibilityState = 'hidden' | 'visible' | 'prerender' | 'unloaded';
6 +
7 +declare class WindowClient extends Client {
8 + visibilityState: VisibilityState;
9 + focused: boolean;
10 + focus(): Promise<WindowClient>;
11 + navigate(url: string): Promise<WindowClient>;
12 +}
13 +
14 +declare class Client {
15 + id: string;
16 + reserved: boolean;
17 + url: string;
18 + frameType: FrameType;
19 + postMessage(message: any, transfer?: Iterator<any> | Array<any>): void;
20 +}
21 +
22 +declare class ExtendableEvent extends Event {
23 + waitUntil(f: Promise<mixed>): void;
24 +}
25 +
26 +type NotificationEvent$Init = {
27 + ...Event$Init,
28 + notification: Notification,
29 + action?: string,
30 + ...
31 +};
32 +
33 +declare class NotificationEvent extends ExtendableEvent {
34 + constructor(type: string, eventInitDict?: NotificationEvent$Init): void;
35 + +notification: Notification;
36 + +action: string;
37 +}
38 +
39 +type ForeignFetchOptions = {
40 + scopes: Iterator<string>,
41 + origins: Iterator<string>,
42 + ...
43 +};
44 +
45 +declare class InstallEvent extends ExtendableEvent {
46 + registerForeignFetch(options: ForeignFetchOptions): void;
47 +}
48 +
49 +declare class FetchEvent extends ExtendableEvent {
50 + request: Request;
51 + clientId: string;
52 + isReload: boolean;
53 + respondWith(response: Response | Promise<Response>): void;
54 + preloadResponse: Promise<?Response>;
55 +}
56 +
57 +type ClientType = 'window' | 'worker' | 'sharedworker' | 'all';
58 +type ClientQueryOptions = {
59 + includeUncontrolled?: boolean,
60 + includeReserved?: boolean,
61 + type?: ClientType,
62 + ...
63 +};
64 +
65 +declare class Clients {
66 + get(id: string): Promise<?Client>;
67 + matchAll(options?: ClientQueryOptions): Promise<Array<Client>>;
68 + openWindow(url: string): Promise<?WindowClient>;
69 + claim(): Promise<void>;
70 +}
71 +
72 +type ServiceWorkerState =
73 + | 'installing'
74 + | 'installed'
75 + | 'activating'
76 + | 'activated'
77 + | 'redundant';
78 +
79 +declare class ServiceWorker extends EventTarget {
80 + scriptURL: string;
81 + state: ServiceWorkerState;
82 +
83 + postMessage(message: any, transfer?: Iterator<any>): void;
84 +
85 + onstatechange?: EventHandler;
86 +}
87 +
88 +declare class NavigationPreloadState {
89 + enabled: boolean;
90 + headerValue: string;
91 +}
92 +
93 +declare class NavigationPreloadManager {
94 + enable: Promise<void>;
95 + disable: Promise<void>;
96 + setHeaderValue(value: string): Promise<void>;
97 + getState: Promise<NavigationPreloadState>;
98 +}
99 +
100 +type PushSubscriptionOptions = {
101 + userVisibleOnly?: boolean,
102 + applicationServerKey?: string | ArrayBuffer | $ArrayBufferView,
103 + ...
104 +};
105 +
106 +declare class PushSubscriptionJSON {
107 + endpoint: string;
108 + expirationTime: number | null;
109 + keys: {[string]: string, ...};
110 +}
111 +
112 +declare class PushSubscription {
113 + +endpoint: string;
114 + +expirationTime: number | null;
115 + +options: PushSubscriptionOptions;
116 + getKey(name: string): ArrayBuffer | null;
117 + toJSON(): PushSubscriptionJSON;
118 + unsubscribe(): Promise<boolean>;
119 +}
120 +
121 +declare class PushManager {
122 + +supportedContentEncodings: Array<string>;
123 + subscribe(options?: PushSubscriptionOptions): Promise<PushSubscription>;
124 + getSubscription(): Promise<PushSubscription | null>;
125 + permissionState(
126 + options?: PushSubscriptionOptions
127 + ): Promise<'granted' | 'denied' | 'prompt'>;
128 +}
129 +
130 +type ServiceWorkerUpdateViaCache = 'imports' | 'all' | 'none';
131 +
132 +type GetNotificationOptions = {
133 + tag?: string,
134 + ...
135 +};
136 +
137 +declare class ServiceWorkerRegistration extends EventTarget {
138 + +installing: ?ServiceWorker;
139 + +waiting: ?ServiceWorker;
140 + +active: ?ServiceWorker;
141 + +navigationPreload: NavigationPreloadManager;
142 + +scope: string;
143 + +updateViaCache: ServiceWorkerUpdateViaCache;
144 + +pushManager: PushManager;
145 +
146 + getNotifications?: (
147 + filter?: GetNotificationOptions
148 + ) => Promise<$ReadOnlyArray<Notification>>;
149 + showNotification?: (
150 + title: string,
151 + options?: NotificationOptions
152 + ) => Promise<void>;
153 + update(): Promise<void>;
154 + unregister(): Promise<boolean>;
155 +
156 + onupdatefound?: EventHandler;
157 +}
158 +
159 +type WorkerType = 'classic' | 'module';
160 +
161 +type RegistrationOptions = {
162 + scope?: string,
163 + type?: WorkerType,
164 + updateViaCache?: ServiceWorkerUpdateViaCache,
165 + ...
166 +};
167 +
168 +declare class ServiceWorkerContainer extends EventTarget {
169 + +controller: ?ServiceWorker;
170 + +ready: Promise<ServiceWorkerRegistration>;
171 +
172 + getRegistration(
173 + clientURL?: string
174 + ): Promise<ServiceWorkerRegistration | void>;
175 + getRegistrations(): Promise<Iterator<ServiceWorkerRegistration>>;
176 + register(
177 + scriptURL: string | TrustedScriptURL,
178 + options?: RegistrationOptions
179 + ): Promise<ServiceWorkerRegistration>;
180 + startMessages(): void;
181 +
182 + oncontrollerchange?: EventHandler;
183 + onmessage?: EventHandler;
184 + onmessageerror?: EventHandler;
185 +}
186 +
187 +/**
188 + * This feature has been removed from the Web standards.
189 + */
190 +declare class ServiceWorkerMessageEvent extends Event {
191 + data: any;
192 + lastEventId: string;
193 + origin: string;
194 + ports: Array<MessagePort>;
195 + source: ?(ServiceWorker | MessagePort);
196 +}
197 +
198 +declare class ExtendableMessageEvent extends ExtendableEvent {
199 + data: any;
200 + lastEventId: string;
201 + origin: string;
202 + ports: Array<MessagePort>;
203 + source: ?(ServiceWorker | MessagePort);
204 +}
205 +
206 +type CacheQueryOptions = {
207 + ignoreSearch?: boolean,
208 + ignoreMethod?: boolean,
209 + ignoreVary?: boolean,
210 + cacheName?: string,
211 + ...
212 +};
213 +
214 +declare class Cache {
215 + match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response>;
216 + matchAll(
217 + request: RequestInfo,
218 + options?: CacheQueryOptions
219 + ): Promise<Array<Response>>;
220 + add(request: RequestInfo): Promise<void>;
221 + addAll(requests: Array<RequestInfo>): Promise<void>;
222 + put(request: RequestInfo, response: Response): Promise<void>;
223 + delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
224 + keys(
225 + request?: RequestInfo,
226 + options?: CacheQueryOptions
227 + ): Promise<Array<Request>>;
228 +}
229 +
230 +declare class CacheStorage {
231 + match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response>;
232 + has(cacheName: string): Promise<true>;
233 + open(cacheName: string): Promise<Cache>;
234 + delete(cacheName: string): Promise<boolean>;
235 + keys(): Promise<Array<string>>;
236 +}
237 +
238 +// Service worker global scope
239 +// https://www.w3.org/TR/service-workers/#service-worker-global-scope
240 +declare var clients: Clients;
241 +declare var caches: CacheStorage;
242 +declare var registration: ServiceWorkerRegistration;
243 +declare function skipWaiting(): Promise<void>;
244 +declare var onactivate: ?EventHandler;
245 +declare var oninstall: ?EventHandler;
246 +declare var onfetch: ?EventHandler;
247 +declare var onforeignfetch: ?EventHandler;
248 +declare var onmessage: ?EventHandler;
flow-typed/environments/streams.js new
+136
@@ -0,0 +1,136 @@
1 +// flow-typed signature: e6e6768618776352dd676f63502aea4d
2 +// flow-typed version: 40e7dfcbd5/streams/flow_>=v0.261.x
3 +
4 +type TextEncodeOptions = {options?: boolean, ...};
5 +
6 +declare class ReadableStreamController {
7 + constructor(
8 + stream: ReadableStream,
9 + underlyingSource: UnderlyingSource,
10 + size: number,
11 + highWaterMark: number
12 + ): void;
13 +
14 + desiredSize: number;
15 +
16 + close(): void;
17 + enqueue(chunk: any): void;
18 + error(error: Error): void;
19 +}
20 +
21 +declare class ReadableStreamBYOBRequest {
22 + constructor(controller: ReadableStreamController, view: $TypedArray): void;
23 +
24 + view: $TypedArray;
25 +
26 + respond(bytesWritten: number): ?any;
27 + respondWithNewView(view: $TypedArray): ?any;
28 +}
29 +
30 +declare class ReadableByteStreamController extends ReadableStreamController {
31 + constructor(
32 + stream: ReadableStream,
33 + underlyingSource: UnderlyingSource,
34 + highWaterMark: number
35 + ): void;
36 +
37 + byobRequest: ReadableStreamBYOBRequest;
38 +}
39 +
40 +declare class ReadableStreamReader {
41 + constructor(stream: ReadableStream): void;
42 +
43 + closed: boolean;
44 +
45 + cancel(reason: string): void;
46 + read(): Promise<{
47 + value: ?any,
48 + done: boolean,
49 + ...
50 + }>;
51 + releaseLock(): void;
52 +}
53 +
54 +declare interface UnderlyingSource {
55 + autoAllocateChunkSize?: number;
56 + type?: string;
57 +
58 + start?: (controller: ReadableStreamController) => ?Promise<void>;
59 + pull?: (controller: ReadableStreamController) => ?Promise<void>;
60 + cancel?: (reason: string) => ?Promise<void>;
61 +}
62 +
63 +declare class TransformStream {
64 + readable: ReadableStream;
65 + writable: WritableStream;
66 +}
67 +
68 +interface PipeThroughTransformStream {
69 + readable: ReadableStream;
70 + writable: WritableStream;
71 +}
72 +
73 +type PipeToOptions = {
74 + preventClose?: boolean,
75 + preventAbort?: boolean,
76 + preventCancel?: boolean,
77 + ...
78 +};
79 +
80 +type QueuingStrategy = {
81 + highWaterMark: number,
82 + size(chunk: ?any): number,
83 + ...
84 +};
85 +
86 +declare class ReadableStream {
87 + constructor(
88 + underlyingSource: ?UnderlyingSource,
89 + queuingStrategy: ?QueuingStrategy
90 + ): void;
91 +
92 + locked: boolean;
93 +
94 + cancel(reason: string): void;
95 + getReader(): ReadableStreamReader;
96 + pipeThrough(transform: PipeThroughTransformStream, options: ?any): void;
97 + pipeTo(dest: WritableStream, options: ?PipeToOptions): Promise<void>;
98 + tee(): [ReadableStream, ReadableStream];
99 +}
100 +
101 +declare interface WritableStreamController {
102 + error(error: Error): void;
103 +}
104 +
105 +declare interface UnderlyingSink {
106 + autoAllocateChunkSize?: number;
107 + type?: string;
108 +
109 + abort?: (reason: string) => ?Promise<void>;
110 + close?: (controller: WritableStreamController) => ?Promise<void>;
111 + start?: (controller: WritableStreamController) => ?Promise<void>;
112 + write?: (chunk: any, controller: WritableStreamController) => ?Promise<void>;
113 +}
114 +
115 +declare interface WritableStreamWriter {
116 + closed: Promise<any>;
117 + desiredSize?: number;
118 + ready: Promise<any>;
119 +
120 + abort(reason: string): ?Promise<any>;
121 + close(): Promise<any>;
122 + releaseLock(): void;
123 + write(chunk: any): Promise<any>;
124 +}
125 +
126 +declare class WritableStream {
127 + constructor(
128 + underlyingSink: ?UnderlyingSink,
129 + queuingStrategy: QueuingStrategy
130 + ): void;
131 +
132 + locked: boolean;
133 +
134 + abort(reason: string): void;
135 + getWriter(): WritableStreamWriter;
136 +}
flow-typed/environments/web-animations.js new
+193
@@ -0,0 +1,193 @@
1 +// flow-typed signature: 4631a74b6a0e6a1b4de2ba8c7bb141d6
2 +// flow-typed version: 3e51657e95/web-animations/flow_>=v0.261.x
3 +
4 +// https://www.w3.org/TR/web-animations-1/
5 +
6 +type AnimationPlayState = 'idle' | 'running' | 'paused' | 'finished';
7 +
8 +type AnimationReplaceState = 'active' | 'removed' | 'persisted';
9 +
10 +type CompositeOperation = 'replace' | 'add' | 'accumulate';
11 +
12 +type CompositeOperationOrAuto = 'replace' | 'add' | 'accumulate' | 'auto';
13 +
14 +type FillMode = 'none' | 'forwards' | 'backwards' | 'both' | 'auto';
15 +
16 +// This is actually web-animations-2
17 +type IterationCompositeOperation = 'replace' | 'accumulate';
18 +
19 +type PlaybackDirection =
20 + | 'normal'
21 + | 'reverse'
22 + | 'alternate'
23 + | 'alternate-reverse';
24 +
25 +type AnimationPlaybackEvent$Init = Event$Init & {
26 + currentTime?: number | null,
27 + timelineTime?: number | null,
28 + ...
29 +};
30 +
31 +type BaseComputedKeyframe = {|
32 + composite: CompositeOperationOrAuto,
33 + computedOffset: number,
34 + easing: string,
35 + offset: number | null,
36 +|};
37 +
38 +type BaseKeyframe = {|
39 + composite: CompositeOperationOrAuto,
40 + easing: string,
41 + offset: number | null,
42 +|};
43 +
44 +type BasePropertyIndexedKeyframe = {|
45 + composite: CompositeOperationOrAuto | Array<CompositeOperationOrAuto>,
46 + easing: string | Array<string>,
47 + offset: number | null | Array<number | null>,
48 +|};
49 +
50 +type ComputedEffectTiming = {|
51 + ...EffectTiming,
52 + currentIteration: number | null,
53 + progress: number | null,
54 +|};
55 +
56 +type ComputedKeyframe = {
57 + composite: CompositeOperationOrAuto,
58 + computedOffset: number,
59 + easing: string,
60 + offset: number | null,
61 + [property: string]: string | number | null | void,
62 + ...
63 +};
64 +
65 +type DocumentTimelineOptions = {|
66 + originTime: number,
67 +|};
68 +
69 +type EffectTiming = {|
70 + direction: PlaybackDirection,
71 + easing: string,
72 + fill: FillMode,
73 + iterations: number,
74 + iterationStart: number,
75 +|};
76 +
77 +type GetAnimationsOptions = {|
78 + pseudoElement: string | null,
79 + subtree: boolean,
80 +|};
81 +
82 +type KeyframeAnimationOptions = {|
83 + ...KeyframeEffectOptions,
84 + id: string,
85 + timeline: AnimationTimeline | null,
86 +|};
87 +
88 +type KeyframeEffectOptions = {|
89 + ...EffectTiming,
90 + composite: CompositeOperation,
91 + pseudoElement: string | null,
92 +|};
93 +
94 +type Keyframe = {
95 + composite?: CompositeOperationOrAuto,
96 + easing?: string,
97 + offset?: number | null,
98 + [property: string]: string | number | null | void,
99 + ...
100 +};
101 +
102 +type OptionalEffectTiming = Partial<EffectTiming>;
103 +
104 +type PropertyIndexedKeyframes = {
105 + composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[],
106 + easing?: string | string[],
107 + offset?: number | (number | null)[],
108 + [property: string]:
109 + | string
110 + | string[]
111 + | number
112 + | null
113 + | (number | null)[]
114 + | void,
115 + ...
116 +};
117 +
118 +declare class Animation extends EventTarget {
119 + constructor(
120 + effect?: AnimationEffect | null,
121 + timeline?: AnimationTimeline | null
122 + ): void;
123 +
124 + id: string;
125 + effect: AnimationEffect | null;
126 + timeline: AnimationTimeline | null;
127 + startTime: number | null;
128 + currentTime: number | null;
129 + playbackRate: number;
130 + +playState: AnimationPlayState;
131 + +replaceState: AnimationReplaceState;
132 + +pending: boolean;
133 + +ready: Promise<Animation>;
134 + +finished: Promise<Animation>;
135 + onfinish: ?(ev: AnimationPlaybackEvent) => mixed;
136 + oncancel: ?(ev: AnimationPlaybackEvent) => mixed;
137 + onremove: ?(ev: AnimationPlaybackEvent) => mixed;
138 + cancel(): void;
139 + finish(): void;
140 + play(): void;
141 + pause(): void;
142 + updatePlaybackRate(playbackRate: number): void;
143 + reverse(): void;
144 + persist(): void;
145 + commitStyles(): void;
146 +}
147 +
148 +declare class AnimationEffect {
149 + getTiming(): EffectTiming;
150 + getComputedTiming(): ComputedEffectTiming;
151 + updateTiming(timing?: OptionalEffectTiming): void;
152 +}
153 +
154 +declare class AnimationPlaybackEvent extends Event {
155 + constructor(
156 + type: string,
157 + animationEventInitDict?: AnimationPlaybackEvent$Init
158 + ): void;
159 + +currentTime: number | null;
160 + +timelineTime: number | null;
161 +}
162 +
163 +declare class AnimationTimeline {
164 + +currentTime: number | null;
165 +}
166 +
167 +declare class DocumentTimeline extends AnimationTimeline {
168 + constructor(options?: DocumentTimelineOptions): void;
169 +}
170 +
171 +declare class KeyframeEffect extends AnimationEffect {
172 + constructor(
173 + target: Element | null,
174 + keyframes: Keyframe[] | PropertyIndexedKeyframes | null,
175 + options?: number | KeyframeEffectOptions
176 + ): void;
177 + constructor(source: KeyframeEffect): void;
178 +
179 + target: Element | null;
180 + composite: CompositeOperation;
181 + // This is actually web-animations-2
182 + iterationComposite: IterationCompositeOperation;
183 + getKeyframes(): ComputedKeyframe[];
184 + setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void;
185 +}
186 +
187 +declare class mixin$Animatable {
188 + animate(
189 + keyframes: Keyframe[] | PropertyIndexedKeyframes | null,
190 + options?: number | KeyframeAnimationOptions
191 + ): Animation;
192 + getAnimations(options?: GetAnimationsOptions): Array<Animation>;
193 +}
flow-typed/npm/error-stack-parser_v2.x.x.js new
+60
@@ -0,0 +1,60 @@
1 +// flow-typed signature: 132e48034ef4756600e1d98681a166b5
2 +// flow-typed version: c6154227d1/error-stack-parser_v2.x.x/flow_>=v0.104.x
3 +
4 +declare module 'error-stack-parser' {
5 + declare interface StackFrame {
6 + constructor(object: StackFrame): StackFrame;
7 +
8 + isConstructor?: boolean;
9 + getIsConstructor(): boolean;
10 + setIsConstructor(): void;
11 +
12 + isEval?: boolean;
13 + getIsEval(): boolean;
14 + setIsEval(): void;
15 +
16 + isNative?: boolean;
17 + getIsNative(): boolean;
18 + setIsNative(): void;
19 +
20 + isTopLevel?: boolean;
21 + getIsTopLevel(): boolean;
22 + setIsTopLevel(): void;
23 +
24 + columnNumber?: number;
25 + getColumnNumber(): number;
26 + setColumnNumber(): void;
27 +
28 + lineNumber?: number;
29 + getLineNumber(): number;
30 + setLineNumber(): void;
31 +
32 + fileName?: string;
33 + getFileName(): string;
34 + setFileName(): void;
35 +
36 + functionName?: string;
37 + getFunctionName(): string;
38 + setFunctionName(): void;
39 +
40 + source?: string;
41 + getSource(): string;
42 + setSource(): void;
43 +
44 + args?: any[];
45 + getArgs(): any[];
46 + setArgs(): void;
47 +
48 + evalOrigin?: StackFrame;
49 + getEvalOrigin(): StackFrame;
50 + setEvalOrigin(): void;
51 +
52 + toString(): string;
53 + }
54 +
55 + declare class ErrorStackParser {
56 + parse(error: Error): Array<StackFrame>;
57 + }
58 +
59 + declare module.exports: ErrorStackParser;
60 +}
flow-typed/npm/minimist_v1.x.x.js new
+27
@@ -0,0 +1,27 @@
1 +// flow-typed signature: d48da8db828529253fc20b80747846ea
2 +// flow-typed version: c6154227d1/minimist_v1.x.x/flow_>=v0.104.x
3 +
4 +declare module 'minimist' {
5 + declare type minimistOptions = {
6 + string?: string | Array<string>,
7 + boolean?: boolean | string | Array<string>,
8 + alias?: {[arg: string]: string | Array<string>, ...},
9 + default?: {[arg: string]: any, ...},
10 + stopEarly?: boolean,
11 + // TODO: Strings as keys don't work...
12 + // '--'? boolean,
13 + unknown?: (param: string) => boolean,
14 + ...
15 + };
16 +
17 + declare type minimistOutput = {
18 + [flag: string]: string | boolean,
19 + _: Array<string>,
20 + ...
21 + };
22 +
23 + declare module.exports: (
24 + argv: Array<string>,
25 + opts?: minimistOptions
26 + ) => minimistOutput;
27 +}
package.json
+4 -2
@@ -74,8 +74,9 @@
74 "eslint-plugin-react-internal": "link:./scripts/eslint-rules",
75 "fbjs-scripts": "^3.0.1",
76 "filesize": "^6.0.1",
77 - "flow-bin": "^0.261",
78 - "flow-remove-types": "^2.261",
77 + "flow-bin": "^0.263",
78 + "flow-remove-types": "^2.263",
79 + "flow-typed": "^4.1.1",
80 "glob": "^7.1.6",
81 "glob-stream": "^6.1.0",
82 "google-closure-compiler": "^20230206.0.0",
@@ -126,6 +127,7 @@
127 "build-for-devtools-prod": "yarn build-for-devtools --type=NODE_PROD",
128 "build-for-flight-dev": "cross-env RELEASE_CHANNEL=experimental node ./scripts/rollup/build.js react/index,react/jsx,react.react-server,react-dom/index,react-dom/client,react-dom/server,react-dom.react-server,react-dom-server.node,react-dom-server-legacy.node,scheduler,react-server-dom-webpack/ --type=NODE_DEV,ESM_PROD,NODE_ES2015 && mv ./build/node_modules ./build/oss-experimental",
129 "build-for-vt-dev": "cross-env RELEASE_CHANNEL=experimental node ./scripts/rollup/build.js react/index,react/jsx,react-dom/index,react-dom/client,react-dom/server,react-dom-server.node,react-dom-server-legacy.node,scheduler --type=NODE_DEV && mv ./build/node_modules ./build/oss-experimental",
130 + "flow-typed-install": "yarn flow-typed install --skip --skipFlowRestart --ignore-deps=dev",
131 "linc": "node ./scripts/tasks/linc.js",
132 "lint": "node ./scripts/tasks/eslint.js",
133 "lint-build": "node ./scripts/rollup/validate/index.js",
packages/react-devtools-shared/src/backend/views/utils.js
+3
@@ -40,6 +40,7 @@ export function getOwnerIframe(node: HTMLElement): HTMLElement | null {
40 // offset added to compensate for its border.
41 export function getBoundingClientRectWithBorderOffset(node: HTMLElement): Rect {
42 const dimensions = getElementDimensions(node);
43 + // $FlowFixMe[incompatible-variance]
44 return mergeRectOffsets([
45 node.getBoundingClientRect(),
46 {
@@ -102,8 +103,10 @@ export function getNestedBoundingClientRect(
103 }
104 }
105
106 + // $FlowFixMe[incompatible-variance]
107 return mergeRectOffsets(rects);
108 } else {
109 + // $FlowFixMe[incompatible-variance]
110 return node.getBoundingClientRect();
111 }
112 }
packages/react-devtools-shared/src/devtools/views/Components/Components.js
+4 -3
@@ -24,6 +24,7 @@ import SettingsModal from 'react-devtools-shared/src/devtools/views/Settings/Set
24 import {NativeStyleContextController} from './NativeStyleEditor/context';
25
26 import styles from './Components.css';
27 +import typeof {SyntheticPointerEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
28
29 type Orientation = 'horizontal' | 'vertical';
30
@@ -79,17 +80,17 @@ function Components(_: {}) {
80 return () => clearTimeout(timeoutID);
81 }, [horizontalPercentage, verticalPercentage]);
82
82 - const onResizeStart = (event: SyntheticPointerEvent<HTMLElement>) => {
83 + const onResizeStart = (event: SyntheticPointerEvent) => {
84 const element = event.currentTarget;
85 element.setPointerCapture(event.pointerId);
86 };
87
87 - const onResizeEnd = (event: SyntheticPointerEvent<HTMLElement>) => {
88 + const onResizeEnd = (event: SyntheticPointerEvent) => {
89 const element = event.currentTarget;
90 element.releasePointerCapture(event.pointerId);
91 };
92
92 - const onResize = (event: SyntheticPointerEvent<HTMLElement>) => {
93 + const onResize = (event: SyntheticPointerEvent) => {
94 const element = event.currentTarget;
95 const isResizing = element.hasPointerCapture(event.pointerId);
96 if (!isResizing) {
packages/react-devtools-shared/src/devtools/views/Profiler/ChartNode.js
+5 -4
@@ -10,16 +10,17 @@
10 import * as React from 'react';
11
12 import styles from './ChartNode.css';
13 +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
14
15 type Props = {
16 color: string,
17 height: number,
18 isDimmed?: boolean,
19 label: string,
19 - onClick: (event: SyntheticMouseEvent<any>) => mixed,
20 - onDoubleClick?: (event: SyntheticMouseEvent<any>) => mixed,
21 - onMouseEnter: (event: SyntheticMouseEvent<any>) => mixed,
22 - onMouseLeave: (event: SyntheticMouseEvent<any>) => mixed,
20 + onClick: (event: SyntheticMouseEvent) => mixed,
21 + onDoubleClick?: (event: SyntheticMouseEvent) => mixed,
22 + onMouseEnter: (event: SyntheticMouseEvent) => mixed,
23 + onMouseLeave: (event: SyntheticMouseEvent) => mixed,
24 placeLabelAboveNode?: boolean,
25 textStyle?: Object,
26 width: number,
packages/react-devtools-shared/src/devtools/views/Profiler/CommitFlamegraphListItem.js
+2 -1
@@ -17,6 +17,7 @@ import {SettingsContext} from '../Settings/SettingsContext';
17
18 import type {ChartNode as ChartNodeType} from './FlamegraphChartBuilder';
19 import type {ItemData} from './CommitFlamegraph';
20 +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
21
22 type Props = {
23 data: ItemData,
@@ -41,7 +42,7 @@ function CommitFlamegraphListItem({data, index, style}: Props): React.Node {
42 const {lineHeight} = useContext(SettingsContext);
43
44 const handleClick = useCallback(
44 - (event: SyntheticMouseEvent<EventTarget>, id: number, name: string) => {
45 + (event: SyntheticMouseEvent, id: number, name: string) => {
46 event.stopPropagation();
47 selectFiber(id, name);
48 },
packages/react-devtools-shared/src/devtools/views/Profiler/Tooltip.js
+4 -3
@@ -4,6 +4,7 @@ import * as React from 'react';
4 import {useRef} from 'react';
5
6 import styles from './Tooltip.css';
7 +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
8
9 const initialTooltipState = {height: 0, mouseX: 0, mouseY: 0, width: 0};
10
@@ -17,7 +18,7 @@ export default function Tooltip({
18 const tooltipRef = useRef(null);
19
20 // update the position of the tooltip based on current mouse position
20 - const updateTooltipPosition = (event: SyntheticMouseEvent<EventTarget>) => {
21 + const updateTooltipPosition = (event: SyntheticMouseEvent) => {
22 const element = tooltipRef.current;
23 if (element != null) {
24 // first find the mouse position
@@ -30,7 +31,7 @@ export default function Tooltip({
31 }
32 };
33
33 - const onMouseMove = (event: SyntheticMouseEvent<EventTarget>) => {
34 + const onMouseMove = (event: SyntheticMouseEvent) => {
35 updateTooltipPosition(event);
36 };
37
@@ -94,7 +95,7 @@ function getTooltipPosition(
95 // method used to find the current mouse position inside the container
96 function getMousePosition(
97 relativeContainer: null,
97 - mouseEvent: SyntheticMouseEvent<EventTarget>,
98 + mouseEvent: SyntheticMouseEvent,
99 ) {
100 if (relativeContainer !== null) {
101 // Position within the nearest position:relative container.
packages/react-devtools-shared/src/devtools/views/Settings/ProfilerSettings.js
+3 -2
@@ -14,6 +14,7 @@ import {StoreContext} from '../context';
14 import {ProfilerContext} from 'react-devtools-shared/src/devtools/views/Profiler/ProfilerContext';
15
16 import styles from './SettingsShared.css';
17 +import typeof {SyntheticEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
18
19 export default function ProfilerSettings(_: {}): React.Node {
20 const {
@@ -45,7 +46,7 @@ export default function ProfilerSettings(_: {}): React.Node {
46 [store],
47 );
48 const updateMinCommitDuration = useCallback(
48 - (event: SyntheticEvent<HTMLInputElement>) => {
49 + (event: SyntheticEvent) => {
50 const newValue = parseFloat(event.currentTarget.value);
51 setMinCommitDuration(
52 Number.isNaN(newValue) || newValue <= 0 ? 0 : newValue,
@@ -54,7 +55,7 @@ export default function ProfilerSettings(_: {}): React.Node {
55 [setMinCommitDuration],
56 );
57 const updateIsCommitFilterEnabled = useCallback(
57 - (event: SyntheticEvent<HTMLInputElement>) => {
58 + (event: SyntheticEvent) => {
59 const checked = event.currentTarget.checked;
60 setIsCommitFilterEnabled(checked);
61 if (checked) {
packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseRects.js
+7 -3
@@ -23,6 +23,10 @@ import {StoreContext} from '../context';
23 import {useHighlightHostInstance} from '../hooks';
24 import styles from './SuspenseRects.css';
25 import {SuspenseTreeStateContext} from './SuspenseTreeContext';
26 +import typeof {
27 + SyntheticMouseEvent,
28 + SyntheticPointerEvent,
29 +} from 'react-dom-bindings/src/events/SyntheticEvent';
30
31 function SuspenseRect({rect}: {rect: Rect}): React$Node {
32 return (
@@ -55,7 +59,7 @@ function SuspenseRects({
59 return null;
60 }
61
58 - function handleClick(event: SyntheticMouseEvent<>) {
62 + function handleClick(event: SyntheticMouseEvent) {
63 if (event.defaultPrevented) {
64 // Already clicked on an inner rect
65 return;
@@ -64,7 +68,7 @@ function SuspenseRects({
68 dispatch({type: 'SELECT_ELEMENT_BY_ID', payload: suspenseID});
69 }
70
67 - function handlePointerOver(event: SyntheticPointerEvent<>) {
71 + function handlePointerOver(event: SyntheticPointerEvent) {
72 if (event.defaultPrevented) {
73 // Already hovered an inner rect
74 return;
@@ -73,7 +77,7 @@ function SuspenseRects({
77 highlightHostInstance(suspenseID);
78 }
79
76 - function handlePointerLeave(event: SyntheticPointerEvent<>) {
80 + function handlePointerLeave(event: SyntheticPointerEvent) {
81 if (event.defaultPrevented) {
82 // Already hovered an inner rect
83 return;
packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseTab.js
+5 -4
@@ -22,6 +22,7 @@ import styles from './SuspenseTab.css';
22 import SuspenseRects from './SuspenseRects';
23 import SuspenseTreeList from './SuspenseTreeList';
24 import Button from '../Button';
25 +import typeof {SyntheticPointerEvent} from 'react-dom-bindings/src/events/SyntheticEvent';
26
27 type Orientation = 'horizontal' | 'vertical';
28
@@ -180,17 +181,17 @@ function SuspenseTab(_: {}) {
181 treeListHorizontalFraction,
182 ]);
183
183 - const onResizeStart = (event: SyntheticPointerEvent<HTMLElement>) => {
184 + const onResizeStart = (event: SyntheticPointerEvent) => {
185 const element = event.currentTarget;
186 element.setPointerCapture(event.pointerId);
187 };
188
188 - const onResizeEnd = (event: SyntheticPointerEvent<HTMLElement>) => {
189 + const onResizeEnd = (event: SyntheticPointerEvent) => {
190 const element = event.currentTarget;
191 element.releasePointerCapture(event.pointerId);
192 };
193
193 - const onResizeTree = (event: SyntheticPointerEvent<HTMLElement>) => {
194 + const onResizeTree = (event: SyntheticPointerEvent) => {
195 const element = event.currentTarget;
196 const isResizing = element.hasPointerCapture(event.pointerId);
197 if (!isResizing) {
@@ -241,7 +242,7 @@ function SuspenseTab(_: {}) {
242 }
243 };
244
244 - const onResizeTreeList = (event: SyntheticPointerEvent<HTMLElement>) => {
245 + const onResizeTreeList = (event: SyntheticPointerEvent) => {
246 const element = event.currentTarget;
247 const isResizing = element.hasPointerCapture(event.pointerId);
248 if (!isResizing) {
packages/react-dom-bindings/src/client/ReactDOMEventHandle.js
+3 -2
@@ -28,6 +28,7 @@ import {
28 enableScopeAPI,
29 enableCreateEventHandleAPI,
30 } from 'shared/ReactFeatureFlags';
31 +import typeof {SyntheticEvent} from '../events/SyntheticEvent';
32
33 type EventHandleOptions = {
34 capture?: boolean,
@@ -44,7 +45,7 @@ function isReactScope(target: EventTarget | ReactScopeInstance): boolean {
45 function createEventHandleListener(
46 type: DOMEventName,
47 isCapturePhaseListener: boolean,
47 - callback: (SyntheticEvent<EventTarget>) => void,
48 + callback: SyntheticEvent => void,
49 ): ReactDOMEventHandleListener {
50 return {
51 callback,
@@ -111,7 +112,7 @@ export function createEventHandle(
112
113 const eventHandle: ReactDOMEventHandle = (
114 target: EventTarget | ReactScopeInstance,
114 - callback: (SyntheticEvent<EventTarget>) => void,
115 + callback: SyntheticEvent => void,
116 ) => {
117 if (typeof callback !== 'function') {
118 throw new Error(
packages/react-dom-bindings/src/client/ReactDOMEventHandleTypes.js
+3 -2
@@ -9,14 +9,15 @@
9
10 import type {ReactScopeInstance} from 'shared/ReactTypes';
11 import type {DOMEventName} from '../events/DOMEventNames';
12 +import typeof {SyntheticEvent} from '../events/SyntheticEvent';
13
14 export type ReactDOMEventHandle = (
15 target: EventTarget | ReactScopeInstance,
15 - callback: (SyntheticEvent<EventTarget>) => void,
16 + callback: (SyntheticEvent) => void,
17 ) => () => void;
18
19 export type ReactDOMEventHandleListener = {
19 - callback: (SyntheticEvent<EventTarget>) => void,
20 + callback: SyntheticEvent => void,
21 capture: boolean,
22 type: DOMEventName,
23 };
packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js
+43 -10
@@ -242,10 +242,10 @@ export type TransitionStatus = FormStatus;
242
243 export type ViewTransitionInstance = {
244 name: string,
245 - group: Animatable,
246 - imagePair: Animatable,
247 - old: Animatable,
248 - new: Animatable,
245 + group: mixin$Animatable,
246 + imagePair: mixin$Animatable,
247 + old: mixin$Animatable,
248 + new: mixin$Animatable,
249 };
250
251 type SelectionInformation = {
@@ -1430,7 +1430,10 @@ export function applyViewTransitionName(
1430 // simple case by converting it automatically to display: inline-block.
1431 // https://bugs.webkit.org/show_bug.cgi?id=290923
1432 const rects = instance.getClientRects();
1433 - if (countClientRects(rects) === 1) {
1433 + if (
1434 + // $FlowFixMe[incompatible-call]
1435 + countClientRects(rects) === 1
1436 + ) {
1437 // If the instance has a single client rect, that means that it can be
1438 // expressed as a display: inline-block or block.
1439 // This will cause layout thrash but we live with it since inline view transitions
@@ -1535,6 +1538,7 @@ export function cancelViewTransitionName(
1538 if (documentElement !== null) {
1539 documentElement.animate(
1540 {opacity: [0, 0], pointerEvents: ['none', 'none']},
1541 + // $FlowFixMe[incompatible-call]
1542 {
1543 duration: 0,
1544 fill: 'forwards',
@@ -1571,6 +1575,7 @@ export function cancelRootViewTransitionName(rootContainer: Container): void {
1575 documentElement.style.viewTransitionName = 'none';
1576 documentElement.animate(
1577 {opacity: [0, 0], pointerEvents: ['none', 'none']},
1578 + // $FlowFixMe[incompatible-call]
1579 {
1580 duration: 0,
1581 fill: 'forwards',
@@ -1586,6 +1591,7 @@ export function cancelRootViewTransitionName(rootContainer: Container): void {
1591 // whatever is below the animation.
1592 documentElement.animate(
1593 {width: [0, 0], height: [0, 0]},
1594 + // $FlowFixMe[incompatible-call]
1595 {
1596 duration: 0,
1597 fill: 'forwards',
@@ -1970,6 +1976,7 @@ export function hasInstanceAffectedParent(
1976 function cancelAllViewTransitionAnimations(scope: Element) {
1977 // In Safari, we need to manually cancel all manually start animations
1978 // or it'll block or interfer with future transitions.
1979 + // $FlowFixMe[prop-missing]
1980 const animations = scope.getAnimations({subtree: true});
1981 for (let i = 0; i < animations.length; i++) {
1982 const anim = animations[i];
@@ -2137,6 +2144,7 @@ export function startViewTransition(
2144 const readyCallback = () => {
2145 const documentElement: Element = (ownerDocument.documentElement: any);
2146 // Loop through all View Transition Animations.
2147 + // $FlowFixMe[prop-missing]
2148 const animations = documentElement.getAnimations({subtree: true});
2149 for (let i = 0; i < animations.length; i++) {
2150 const animation = animations[i];
@@ -2383,6 +2391,7 @@ function animateGesture(
2391 const reverse = rangeStart > rangeEnd;
2392 if (timeline instanceof AnimationTimeline) {
2393 // Native Timeline
2394 + // $FlowFixMe[incompatible-call]
2395 targetElement.animate(keyframes, {
2396 pseudoElement: pseudoElement,
2397 // Set the timeline to the current gesture timeline to drive the updates.
@@ -2403,6 +2412,7 @@ function animateGesture(
2412 });
2413 } else {
2414 // Custom Timeline
2415 + // $FlowFixMe[incompatible-call]
2416 const animation = targetElement.animate(keyframes, {
2417 pseudoElement: pseudoElement,
2418 // We reset all easing functions to linear so that it feels like you
@@ -2456,6 +2466,7 @@ export function startGestureTransition(
2466 const readyCallback = () => {
2467 const documentElement: Element = (ownerDocument.documentElement: any);
2468 // Loop through all View Transition Animations.
2469 + // $FlowFixMe[prop-missing]
2470 const animations = documentElement.getAnimations({subtree: true});
2471 // First do a pass to collect all known group and new items so we can look
2472 // up if they exist later.
@@ -2471,8 +2482,11 @@ export function startGestureTransition(
2482 } else if (pseudoElement.startsWith('::view-transition')) {
2483 const timing = effect.getTiming();
2484 const duration =
2485 + // $FlowFixMe[prop-missing]
2486 typeof timing.duration === 'number' ? timing.duration : 0;
2487 // TODO: Consider interation count higher than 1.
2488 + // $FlowFixMe[prop-missing]
2489 + // $FlowFixMe[unsafe-addition]
2490 const durationWithDelay = timing.delay + duration;
2491 if (durationWithDelay > longestDuration) {
2492 longestDuration = durationWithDelay;
@@ -2532,11 +2546,17 @@ export function startGestureTransition(
2546 // therefore the timing is from the rangeEnd to the start.
2547 const timing = effect.getTiming();
2548 const duration =
2549 + // $FlowFixMe[prop-missing]
2550 typeof timing.duration === 'number' ? timing.duration : 0;
2551 let adjustedRangeStart =
2552 + // $FlowFixMe[unsafe-addition]
2553 + // $FlowFixMe[prop-missing]
2554 rangeEnd - (duration + timing.delay) * durationToRangeMultipler;
2555 let adjustedRangeEnd =
2539 - rangeEnd - timing.delay * durationToRangeMultipler;
2556 + rangeEnd -
2557 + // $FlowFixMe[prop-missing]
2558 + // $FlowFixMe[unsafe-arithmetic]
2559 + timing.delay * durationToRangeMultipler;
2560 if (
2561 timing.direction === 'reverse' ||
2562 timing.direction === 'alternate-reverse'
@@ -2594,6 +2614,7 @@ export function startGestureTransition(
2614 // you can swipe back again. We can prevent this by adding a paused Animation
2615 // that never stops. This seems to keep all running Animations alive until
2616 // we explicitly abort (or something forces the View Transition to cancel).
2617 + // $FlowFixMe[incompatible-call]
2618 const blockingAnim = documentElement.animate([{}, {}], {
2619 pseudoElement: '::view-transition',
2620 duration: 1,
@@ -2658,7 +2679,7 @@ export function stopViewTransition(transition: RunningViewTransition) {
2679 transition.skipTransition();
2680 }
2681
2661 -interface ViewTransitionPseudoElementType extends Animatable {
2682 +interface ViewTransitionPseudoElementType extends mixin$Animatable {
2683 _scope: HTMLElement;
2684 _selector: string;
2685 getComputedStyle(): CSSStyleDeclaration;
@@ -2684,7 +2705,11 @@ ViewTransitionPseudoElement.prototype.animate = function (
2705 ? {
2706 duration: options,
2707 }
2687 - : Object.assign(({}: KeyframeAnimationOptions), options);
2708 + : Object.assign(
2709 + (// $FlowFixMe[prop-missing]
2710 + {}: KeyframeAnimationOptions),
2711 + options,
2712 + );
2713 opts.pseudoElement = this._selector;
2714 // TODO: Handle multiple child instances.
2715 return this._scope.animate(keyframes, opts);
@@ -2696,7 +2721,10 @@ ViewTransitionPseudoElement.prototype.getAnimations = function (
2721 ): Animation[] {
2722 const scope = this._scope;
2723 const selector = this._selector;
2699 - const animations = scope.getAnimations({subtree: true});
2724 + const animations = scope.getAnimations(
2725 + // $FlowFixMe[prop-missing]
2726 + {subtree: true},
2727 + );
2728 const result = [];
2729 for (let i = 0; i < animations.length; i++) {
2730 const effect: null | {
@@ -5335,6 +5363,7 @@ function insertStylesheet(
5363 let prior = last;
5364 for (let i = 0; i < nodes.length; i++) {
5365 const node = nodes[i];
5366 + // $FlowFixMe[prop-missing]
5367 const nodePrecedence = node.dataset.precedence;
5368 if (nodePrecedence === precedence) {
5369 prior = node;
@@ -6110,7 +6139,11 @@ function insertStylesheetIntoRoot(
6139 // and will be hoisted by the Fizz runtime imminently.
6140 node.getAttribute('media') !== 'not all'
6141 ) {
6113 - precedences.set(node.dataset.precedence, node);
6142 + precedences.set(
6143 + // $FlowFixMe[prop-missing]
6144 + node.dataset.precedence,
6145 + node,
6146 + );
6147 last = node;
6148 }
6149 }
packages/react-dom-bindings/src/events/SyntheticEvent.js
+1
@@ -229,6 +229,7 @@ const MouseEventInterface: EventInterfaceType = {
229 return lastMovementY;
230 },
231 };
232 +
233 export const SyntheticMouseEvent: $FlowFixMe =
234 createSyntheticEvent(MouseEventInterface);
235
packages/react-dom/src/ReactDOMSharedInternals.js
+1 -3
@@ -21,9 +21,7 @@ type ReactDOMInternals = {
21 p /* currentUpdatePriority */: EventPriority,
22 findDOMNode:
23 | null
24 - | ((
25 - componentOrElement: React$Component<any, any>,
26 - ) => null | Element | Text),
24 + | ((componentOrElement: component(...props: any)) => null | Element | Text),
25 };
26
27 function requestFormReset(element: HTMLFormElement) {
packages/react-dom/src/ReactDOMSharedInternalsFB.js
+1 -3
@@ -20,9 +20,7 @@ type ReactDOMInternals = {
20 p /* currentUpdatePriority */: EventPriority,
21 findDOMNode:
22 | null
23 - | ((
24 - componentOrElement: React$Component<any, any>,
25 - ) => null | Element | Text),
23 + | ((componentOrElement: component(...props: any)) => null | Element | Text),
24 };
25
26 const DefaultDispatcher: HostDispatcher = {
packages/react-dom/src/client/ReactDOMClient.js
+1 -1
@@ -41,7 +41,7 @@ if (__DEV__) {
41 }
42
43 function findDOMNode(
44 - componentOrElement: React$Component<any, any>,
44 + componentOrElement: component(...props: any),
45 ): null | Element | Text {
46 return findHostInstance(componentOrElement);
47 }
packages/react-dom/src/client/ReactDOMClientFB.js
+1 -1
@@ -109,7 +109,7 @@ const flushSync: typeof flushSyncIsomorphic = disableLegacyMode
109 : flushSyncFromReconciler;
110
111 function findDOMNode(
112 - componentOrElement: React$Component<any, any>,
112 + componentOrElement: component(...props: any),
113 ): null | Element | Text {
114 return findHostInstance(componentOrElement);
115 }
packages/react-dom/src/client/ReactDOMRoot.js
+2 -2
@@ -39,7 +39,7 @@ export type CreateRootOptions = {
39 error: mixed,
40 errorInfo: {
41 +componentStack?: ?string,
42 - +errorBoundary?: ?React$Component<any, any>,
42 + +errorBoundary?: ?component(...props: any),
43 },
44 ) => void,
45 onRecoverableError?: (
@@ -65,7 +65,7 @@ export type HydrateRootOptions = {
65 error: mixed,
66 errorInfo: {
67 +componentStack?: ?string,
68 - +errorBoundary?: ?React$Component<any, any>,
68 + +errorBoundary?: ?component(...props: any),
69 },
70 ) => void,
71 onRecoverableError?: (
packages/react-dom/src/client/ReactDOMRootFB.js
+6 -6
@@ -106,7 +106,7 @@ function wwwOnCaughtError(
106 error: mixed,
107 errorInfo: {
108 +componentStack?: ?string,
109 - +errorBoundary?: ?React$Component<any, any>,
109 + +errorBoundary?: ?component(),
110 },
111 ): void {
112 const errorBoundary = errorInfo.errorBoundary;
@@ -216,7 +216,7 @@ const noopOnDefaultTransitionIndicator = noop;
216 function legacyCreateRootFromDOMContainer(
217 container: Container,
218 initialChildren: ReactNodeList,
219 - parentComponent: ?React$Component<any, any>,
219 + parentComponent: ?component(...props: any),
220 callback: ?Function,
221 isHydrationContainer: boolean,
222 ): FiberRoot {
@@ -314,12 +314,12 @@ function warnOnInvalidCallback(callback: mixed): void {
314 }
315
316 function legacyRenderSubtreeIntoContainer(
317 - parentComponent: ?React$Component<any, any>,
317 + parentComponent: ?component(...props: any),
318 children: ReactNodeList,
319 container: Container,
320 forceHydrate: boolean,
321 callback: ?Function,
322 -): React$Component<any, any> | PublicInstance | null {
322 +): component(...props: any) | PublicInstance | null {
323 if (__DEV__) {
324 topLevelUpdateWarnings(container);
325 warnOnInvalidCallback(callback === undefined ? null : callback);
@@ -352,7 +352,7 @@ function legacyRenderSubtreeIntoContainer(
352 }
353
354 export function findDOMNode(
355 - componentOrElement: Element | ?React$Component<any, any>,
355 + componentOrElement: Element | ?component(...props: any),
356 ): null | Element | Text {
357 if (__DEV__) {
358 const owner = currentOwner;
@@ -387,7 +387,7 @@ export function render(
387 element: React$Element<any>,
388 container: Container,
389 callback: ?Function,
390 -): React$Component<any, any> | PublicInstance | null {
390 +): component(...props: any) | PublicInstance | null {
391 if (disableLegacyMode) {
392 if (__DEV__) {
393 console.error(
packages/react-native-renderer/src/ReactFabric.js
+1 -1
@@ -78,7 +78,7 @@ function nativeOnCaughtError(
78 error: mixed,
79 errorInfo: {
80 +componentStack?: ?string,
81 - +errorBoundary?: ?React$Component<any, any>,
81 + +errorBoundary?: ?component(...props: any),
82 },
83 ): void {
84 const errorBoundary = errorInfo.errorBoundary;
packages/react-native-renderer/src/ReactNativeRenderer.js
+1 -1
@@ -93,7 +93,7 @@ function nativeOnCaughtError(
93 error: mixed,
94 errorInfo: {
95 +componentStack?: ?string,
96 - +errorBoundary?: ?React$Component<any, any>,
96 + +errorBoundary?: ?component(...props: any),
97 },
98 ): void {
99 const errorBoundary = errorInfo.errorBoundary;
packages/react-noop-renderer/src/createReactNoop.js
+1 -1
@@ -1387,7 +1387,7 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
1387 },
1388
1389 findInstance(
1390 - componentOrElement: Element | ?React$Component<any, any>,
1390 + componentOrElement: Element | ?component(...props: any),
1391 ): null | Instance | TextInstance {
1392 if (componentOrElement == null) {
1393 return null;
packages/react-reconciler/src/ReactFiberErrorLogger.js
+1 -1
@@ -61,7 +61,7 @@ export function defaultOnCaughtError(
61 error: mixed,
62 errorInfo: {
63 +componentStack?: ?string,
64 - +errorBoundary?: ?React$Component<any, any>,
64 + +errorBoundary?: ?component(...props: any),
65 },
66 ): void {
67 // Overriding this can silence these warnings e.g. for tests.
packages/react-reconciler/src/ReactFiberReconciler.js
+7 -7
@@ -138,7 +138,7 @@ if (__DEV__) {
138 }
139
140 function getContextForSubtree(
141 - parentComponent: ?React$Component<any, any>,
141 + parentComponent: ?component(...props: any),
142 ): Object {
143 if (!parentComponent) {
144 return emptyContextObject;
@@ -248,7 +248,7 @@ export function createContainer(
248 error: mixed,
249 errorInfo: {
250 +componentStack?: ?string,
251 - +errorBoundary?: ?React$Component<any, any>,
251 + +errorBoundary?: ?component(...props: any),
252 },
253 ) => void,
254 onRecoverableError: (
@@ -298,7 +298,7 @@ export function createHydrationContainer(
298 error: mixed,
299 errorInfo: {
300 +componentStack?: ?string,
301 - +errorBoundary?: ?React$Component<any, any>,
301 + +errorBoundary?: ?component(...props: any),
302 },
303 ) => void,
304 onRecoverableError: (
@@ -355,7 +355,7 @@ export function createHydrationContainer(
355 export function updateContainer(
356 element: ReactNodeList,
357 container: OpaqueRoot,
358 - parentComponent: ?React$Component<any, any>,
358 + parentComponent: ?component(...props: any),
359 callback: ?Function,
360 ): Lane {
361 const current = container.current;
@@ -374,7 +374,7 @@ export function updateContainer(
374 export function updateContainerSync(
375 element: ReactNodeList,
376 container: OpaqueRoot,
377 - parentComponent: ?React$Component<any, any>,
377 + parentComponent: ?component(...props: any),
378 callback: ?Function,
379 ): Lane {
380 if (!disableLegacyMode && container.tag === LegacyRoot) {
@@ -397,7 +397,7 @@ function updateContainerImpl(
397 lane: Lane,
398 element: ReactNodeList,
399 container: OpaqueRoot,
400 - parentComponent: ?React$Component<any, any>,
400 + parentComponent: ?component(...props: any),
401 callback: ?Function,
402 ): void {
403 if (__DEV__) {
@@ -471,7 +471,7 @@ export {
471
472 export function getPublicRootInstance(
473 container: OpaqueRoot,
474 -): React$Component<any, any> | PublicInstance | null {
474 +): component(...props: any) | PublicInstance | null {
475 const containerFiber = container.current;
476 if (!containerFiber.child) {
477 return null;
packages/react-reconciler/src/ReactFiberRoot.js
+1 -1
@@ -176,7 +176,7 @@ export function createFiberRoot(
176 error: mixed,
177 errorInfo: {
178 +componentStack?: ?string,
179 - +errorBoundary?: ?React$Component<any, any>,
179 + +errorBoundary?: ?component(...props: any),
180 },
181 ) => void,
182 onRecoverableError: (
packages/react-reconciler/src/ReactInternalTypes.js
+1 -1
@@ -273,7 +273,7 @@ type BaseFiberRootProperties = {
273 error: mixed,
274 errorInfo: {
275 +componentStack?: ?string,
276 - +errorBoundary?: ?React$Component<any, any>,
276 + +errorBoundary?: ?component(...props: any),
277 },
278 ) => void,
279 onRecoverableError: (
packages/react-server/src/ReactFizzClassComponent.js
+1 -1
@@ -79,7 +79,7 @@ function warnOnUndefinedDerivedState(type: any, partialState: any) {
79 }
80
81 function warnNoop(
82 - publicInstance: React$Component<any, any>,
82 + publicInstance: component(...props: any),
83 callerName: string,
84 ) {
85 if (__DEV__) {
packages/react-test-renderer/src/ReactTestRenderer.js
+1 -1
@@ -473,7 +473,7 @@ function create(
473 toTree(): mixed,
474 update(newElement: React$Element<any>): any,
475 unmount(): void,
476 - getInstance(): React$Component<any, any> | PublicInstance | null,
476 + getInstance(): component(...props: any) | PublicInstance | null,
477 unstable_flushSync: typeof flushSyncFromReconciler,
478 } {
479 if (__DEV__) {
yarn.lock
+256 -22
@@ -53,6 +53,15 @@
53 dependencies:
54 "@babel/highlight" "^7.12.13"
55
56 +"@babel/code-frame@^7.16.7", "@babel/code-frame@^7.27.1":
57 + version "7.27.1"
58 + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be"
59 + integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==
60 + dependencies:
61 + "@babel/helper-validator-identifier" "^7.27.1"
62 + js-tokens "^4.0.0"
63 + picocolors "^1.1.1"
64 +
65 "@babel/code-frame@^7.21.4":
66 version "7.24.7"
67 resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.24.7.tgz#882fd9e09e8ee324e496bd040401c6f046ef4465"
@@ -70,15 +79,6 @@
79 js-tokens "^4.0.0"
80 picocolors "^1.0.0"
81
73 -"@babel/code-frame@^7.27.1":
74 - version "7.27.1"
75 - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be"
76 - integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==
77 - dependencies:
78 - "@babel/helper-validator-identifier" "^7.27.1"
79 - js-tokens "^4.0.0"
80 - picocolors "^1.1.1"
81 -
82 "@babel/code-frame@^7.8.3":
83 version "7.8.3"
84 resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.8.3.tgz#33e25903d7481181534e12ec0a25f16b6fcf419e"
@@ -871,6 +871,16 @@
871 js-tokens "^4.0.0"
872 picocolors "^1.0.0"
873
874 +"@babel/highlight@^7.16.7":
875 + version "7.25.9"
876 + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.25.9.tgz#8141ce68fc73757946f983b343f1231f4691acc6"
877 + integrity sha512-llL88JShoCsth8fF8R4SJnIn+WLvR6ccFxu1H3FlMhDontdcmZWf2HgIZ7AIqV3Xcck1idlohrN4EUBQz6klbw==
878 + dependencies:
879 + "@babel/helper-validator-identifier" "^7.25.9"
880 + chalk "^2.4.2"
881 + js-tokens "^4.0.0"
882 + picocolors "^1.0.0"
883 +
884 "@babel/highlight@^7.24.7":
885 version "7.24.7"
886 resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.24.7.tgz#a05ab1df134b286558aae0ed41e6c5f731bf409d"
@@ -3272,6 +3282,18 @@
3282 "@jridgewell/resolve-uri" "^3.1.0"
3283 "@jridgewell/sourcemap-codec" "^1.4.14"
3284
3285 +"@kwsites/file-exists@^1.1.1":
3286 + version "1.1.1"
3287 + resolved "https://registry.yarnpkg.com/@kwsites/file-exists/-/file-exists-1.1.1.tgz#ad1efcac13e1987d8dbaf235ef3be5b0d96faa99"
3288 + integrity sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw==
3289 + dependencies:
3290 + debug "^4.1.1"
3291 +
3292 +"@kwsites/promise-deferred@^1.1.1":
3293 + version "1.1.1"
3294 + resolved "https://registry.yarnpkg.com/@kwsites/promise-deferred/-/promise-deferred-1.1.1.tgz#8ace5259254426ccef57f3175bc64ed7095ed919"
3295 + integrity sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw==
3296 +
3297 "@leichtgewicht/ip-codec@^2.0.1":
3298 version "2.0.4"
3299 resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz#b2ac626d6cb9c8718ab459166d4bb405b8ffa78b"
@@ -6335,6 +6357,11 @@ char-regex@^1.0.2:
6357 resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
6358 integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==
6359
6360 +charenc@0.0.2:
6361 + version "0.0.2"
6362 + resolved "https://registry.yarnpkg.com/charenc/-/charenc-0.0.2.tgz#c0a1d2f3a7092e03774bfa83f14c0fc5790a8667"
6363 + integrity sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==
6364 +
6365 cheerio-select@^2.1.0:
6366 version "2.1.0"
6367 resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-2.1.0.tgz#4d8673286b8126ca2a8e42740d5e3c4884ae21b4"
@@ -6641,7 +6668,7 @@ colors@1.0.3:
6668 resolved "https://registry.yarnpkg.com/colors/-/colors-1.0.3.tgz#0433f44d809680fdeb60ed260f1b0c262e82a40b"
6669 integrity sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=
6670
6644 -colors@^1.1.2:
6671 +colors@1.4.0, colors@^1.1.2:
6672 version "1.4.0"
6673 resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
6674 integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
@@ -6683,6 +6710,11 @@ commander@^4.0.0, commander@^4.0.1:
6710 resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068"
6711 integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==
6712
6713 +commander@^6.1.0:
6714 + version "6.2.1"
6715 + resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c"
6716 + integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==
6717 +
6718 commander@^9.1.0:
6719 version "9.5.0"
6720 resolved "https://registry.yarnpkg.com/commander/-/commander-9.5.0.tgz#bc08d1eb5cedf7ccb797a96199d41c7bc3e60d30"
@@ -7072,6 +7104,11 @@ crx@^5.0.0:
7104 node-rsa "^1.0.5"
7105 pbf "^3.2.0"
7106
7107 +crypt@0.0.2:
7108 + version "0.0.2"
7109 + resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b"
7110 + integrity sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==
7111 +
7112 crypto-browserify@~3.2.6:
7113 version "3.2.8"
7114 resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.2.8.tgz#b9b11dbe6d9651dd882a01e6cc467df718ecf189"
@@ -8253,7 +8290,7 @@ eslint-utils@^2.0.0, eslint-utils@^2.1.0:
8290 dependencies:
8291 eslint-visitor-keys "^1.1.0"
8292
8256 -"eslint-v7@npm:eslint@^7.7.0", eslint@^7.7.0:
8293 +"eslint-v7@npm:eslint@^7.7.0":
8294 version "7.32.0"
8295 resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d"
8296 integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA==
@@ -8452,6 +8489,52 @@ eslint@8.57.0:
8489 strip-ansi "^6.0.1"
8490 text-table "^0.2.0"
8491
8492 +eslint@^7.7.0:
8493 + version "7.32.0"
8494 + resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d"
8495 + integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA==
8496 + dependencies:
8497 + "@babel/code-frame" "7.12.11"
8498 + "@eslint/eslintrc" "^0.4.3"
8499 + "@humanwhocodes/config-array" "^0.5.0"
8500 + ajv "^6.10.0"
8501 + chalk "^4.0.0"
8502 + cross-spawn "^7.0.2"
8503 + debug "^4.0.1"
8504 + doctrine "^3.0.0"
8505 + enquirer "^2.3.5"
8506 + escape-string-regexp "^4.0.0"
8507 + eslint-scope "^5.1.1"
8508 + eslint-utils "^2.1.0"
8509 + eslint-visitor-keys "^2.0.0"
8510 + espree "^7.3.1"
8511 + esquery "^1.4.0"
8512 + esutils "^2.0.2"
8513 + fast-deep-equal "^3.1.3"
8514 + file-entry-cache "^6.0.1"
8515 + functional-red-black-tree "^1.0.1"
8516 + glob-parent "^5.1.2"
8517 + globals "^13.6.0"
8518 + ignore "^4.0.6"
8519 + import-fresh "^3.0.0"
8520 + imurmurhash "^0.1.4"
8521 + is-glob "^4.0.0"
8522 + js-yaml "^3.13.1"
8523 + json-stable-stringify-without-jsonify "^1.0.1"
8524 + levn "^0.4.1"
8525 + lodash.merge "^4.6.2"
8526 + minimatch "^3.0.4"
8527 + natural-compare "^1.4.0"
8528 + optionator "^0.9.1"
8529 + progress "^2.0.0"
8530 + regexpp "^3.1.0"
8531 + semver "^7.2.1"
8532 + strip-ansi "^6.0.0"
8533 + strip-json-comments "^3.1.0"
8534 + table "^6.0.9"
8535 + text-table "^0.2.0"
8536 + v8-compile-cache "^2.0.3"
8537 +
8538 espree@10.0.1, espree@^10.0.1:
8539 version "10.0.1"
8540 resolved "https://registry.yarnpkg.com/espree/-/espree-10.0.1.tgz#600e60404157412751ba4a6f3a2ee1a42433139f"
@@ -9215,12 +9298,12 @@ flatted@^3.2.9:
9298 resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.3.1.tgz#21db470729a6734d4997002f439cb308987f567a"
9299 integrity sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==
9300
9218 -flow-bin@^0.261:
9219 - version "0.261.2"
9220 - resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.261.2.tgz#8558c965950f8e38872ea21f66bf04932da2380b"
9221 - integrity sha512-lTYA05K4obAjyrrX4in3sLZyAECSFCDwQiGpZHJLm8ldCk+qcW11Wcxq/CdvyQAOPR7Kpb5BPRSaj4hwEXIAUw==
9301 +flow-bin@^0.263:
9302 + version "0.263.0"
9303 + resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.263.0.tgz#0a836bdf82855d5df9858c781818ce51612be064"
9304 + integrity sha512-FkQywD+7wXru/7/SWJPVnZXUp6CW3XtrVZ26vhAdVfMx9xlwq/Zk/tXcn3OQuiHUA4kQvZNyfgRztp6oXgjsog==
9305
9223 -flow-remove-types@^2.261:
9306 +flow-remove-types@^2.263:
9307 version "2.279.0"
9308 resolved "https://registry.yarnpkg.com/flow-remove-types/-/flow-remove-types-2.279.0.tgz#3a3388d9158eba0f82c40d80d31d9640b883a3f5"
9309 integrity sha512-bPFloMR/A2b/r/sIsf7Ix0LaMicCJNjwhXc4xEEQVzJCIz5u7C7XDaEOXOiqveKlCYK7DcBNn6R01Cbbc9gsYA==
@@ -9229,6 +9312,43 @@ flow-remove-types@^2.261:
9312 pirates "^3.0.2"
9313 vlq "^0.2.1"
9314
9315 +flow-typed@^4.1.1:
9316 + version "4.1.1"
9317 + resolved "https://registry.yarnpkg.com/flow-typed/-/flow-typed-4.1.1.tgz#e4ff8ea37edcb8fb463b72b70787147bf52a1e08"
9318 + integrity sha512-S1NSkTm81UkoSiuDp9vUAY+jYSB8r/Bec1RFqjK3o+XagFu+OQtm1nh3ZyoshHtg1oPKfrSnslXHlqWiP76BSw==
9319 + dependencies:
9320 + "@octokit/rest" "^18.12.0"
9321 + colors "1.4.0"
9322 + flowgen "^1.10.0"
9323 + fs-extra "^8.1.0"
9324 + glob "^7.1.6"
9325 + got "^11.8.5"
9326 + js-yaml "^4.1.0"
9327 + md5 "^2.2.1"
9328 + mkdirp "^1.0.3"
9329 + node-stream-zip "^1.15.0"
9330 + prettier "^1.19.1"
9331 + rimraf "^3.0.2"
9332 + semver "^7.6.3"
9333 + simple-git "^3.10.0"
9334 + table "^6.7.3"
9335 + which "^2.0.2"
9336 + yargs "^15.1.0"
9337 +
9338 +flowgen@^1.10.0:
9339 + version "1.21.0"
9340 + resolved "https://registry.yarnpkg.com/flowgen/-/flowgen-1.21.0.tgz#f7ecb693892c4bd069492dbf77db561bbb451aa9"
9341 + integrity sha512-pFNFFyMLRmW6njhOIm5TrbGUDTv64aujmys2KrkRE2NYD8sXwJUyicQRwU5SPRBRJnFSD/FNlnHo2NnHI5eJSw==
9342 + dependencies:
9343 + "@babel/code-frame" "^7.16.7"
9344 + "@babel/highlight" "^7.16.7"
9345 + commander "^6.1.0"
9346 + lodash "^4.17.20"
9347 + prettier "^2.5.1"
9348 + shelljs "^0.8.4"
9349 + typescript "~4.4.4"
9350 + typescript-compiler "^1.4.1-2"
9351 +
9352 follow-redirects@^1.0.0:
9353 version "1.15.6"
9354 resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b"
@@ -10685,7 +10805,7 @@ is-boolean-object@^1.1.0:
10805 dependencies:
10806 call-bind "^1.0.2"
10807
10688 -is-buffer@^1.1.5:
10808 +is-buffer@^1.1.5, is-buffer@~1.1.6:
10809 version "1.1.6"
10810 resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
10811 integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
@@ -12304,7 +12424,7 @@ lodash.union@^4.6.0:
12424 resolved "https://registry.yarnpkg.com/lodash.union/-/lodash.union-4.6.0.tgz#48bb5088409f16f1821666641c44dd1aaae3cd88"
12425 integrity sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=
12426
12307 -lodash@^4.14.0, lodash@^4.17.11, lodash@^4.17.13, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21, lodash@^4.8.0, lodash@~4.17.2:
12427 +lodash@^4.14.0, lodash@^4.17.11, lodash@^4.17.13, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.8.0, lodash@~4.17.2:
12428 version "4.17.21"
12429 resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
12430 integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
@@ -12509,6 +12629,15 @@ matcher@^3.0.0:
12629 dependencies:
12630 escape-string-regexp "^4.0.0"
12631
12632 +md5@^2.2.1:
12633 + version "2.3.0"
12634 + resolved "https://registry.yarnpkg.com/md5/-/md5-2.3.0.tgz#c3da9a6aae3a30b46b7b0c349b87b110dc3bda4f"
12635 + integrity sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==
12636 + dependencies:
12637 + charenc "0.0.2"
12638 + crypt "0.0.2"
12639 + is-buffer "~1.1.6"
12640 +
12641 mdn-data@2.0.14:
12642 version "2.0.14"
12643 resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.14.tgz#7113fc4281917d63ce29b43446f701e68c25ba50"
@@ -12794,6 +12923,11 @@ mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@~0.5.1:
12923 dependencies:
12924 minimist "^1.2.5"
12925
12926 +mkdirp@^1.0.3:
12927 + version "1.0.4"
12928 + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
12929 + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
12930 +
12931 moment@^2.19.3:
12932 version "2.30.1"
12933 resolved "https://registry.yarnpkg.com/moment/-/moment-2.30.1.tgz#f8c91c07b7a786e30c59926df530b4eac96974ae"
@@ -13058,6 +13192,11 @@ node-rsa@^1.0.5:
13192 dependencies:
13193 asn1 "^0.2.4"
13194
13195 +node-stream-zip@^1.15.0:
13196 + version "1.15.0"
13197 + resolved "https://registry.yarnpkg.com/node-stream-zip/-/node-stream-zip-1.15.0.tgz#158adb88ed8004c6c49a396b50a6a5de3bca33ea"
13198 + integrity sha512-LN4fydt9TqhZhThkZIVQnF9cwjU3qmUH9h78Mx/K7d3VvfRqqwthLwJEUOEL0QPZ0XQmNN7be5Ggit5+4dq3Bw==
13199 +
13200 node-version@^1.0.0:
13201 version "1.2.0"
13202 resolved "https://registry.yarnpkg.com/node-version/-/node-version-1.2.0.tgz#34fde3ffa8e1149bd323983479dda620e1b5060d"
@@ -14207,6 +14346,16 @@ prettier@*, prettier@^3.3.3:
14346 resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.3.3.tgz#30c54fe0be0d8d12e6ae61dbb10109ea00d53105"
14347 integrity sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==
14348
14349 +prettier@^1.19.1:
14350 + version "1.19.1"
14351 + resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.19.1.tgz#f7d7f5ff8a9cd872a7be4ca142095956a60797cb"
14352 + integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==
14353 +
14354 +prettier@^2.5.1:
14355 + version "2.8.8"
14356 + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da"
14357 + integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==
14358 +
14359 pretty-format@^29.4.1:
14360 version "29.4.1"
14361 resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.4.1.tgz#0da99b532559097b8254298da7c75a0785b1751c"
@@ -15520,6 +15669,11 @@ semver@^7.5.4:
15669 dependencies:
15670 lru-cache "^6.0.0"
15671
15672 +semver@^7.6.3:
15673 + version "7.7.2"
15674 + resolved "https://registry.yarnpkg.com/semver/-/semver-7.7.2.tgz#67d99fdcd35cec21e6f8b87a7fd515a33f982b58"
15675 + integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==
15676 +
15677 send@0.19.0:
15678 version "0.19.0"
15679 resolved "https://registry.yarnpkg.com/send/-/send-0.19.0.tgz#bbc5a388c8ea6c048967049dbeac0e4a3f09d7f8"
@@ -15682,7 +15836,7 @@ shell-quote@^1.7.3:
15836 resolved "https://registry.yarnpkg.com/shell-quote/-/shell-quote-1.8.1.tgz#6dbf4db75515ad5bac63b4f1894c3a154c766680"
15837 integrity sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA==
15838
15685 -shelljs@^0.8.5:
15839 +shelljs@^0.8.4, shelljs@^0.8.5:
15840 version "0.8.5"
15841 resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c"
15842 integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==
@@ -15726,6 +15880,15 @@ signedsource@^2.0.0:
15880 resolved "https://registry.yarnpkg.com/signedsource/-/signedsource-2.0.0.tgz#f72dc0f98f5bca2763b464a555511a84a4da8eee"
15881 integrity sha512-MscTxXbMij5JVgrW1xDiMIc+vFa0+H0+HP+rRrFjwa7ef2VAxIP/4L/E75I5H4xvyb4l1X+a9ch+6Zy5uFu7Fg==
15882
15883 +simple-git@^3.10.0:
15884 + version "3.28.0"
15885 + resolved "https://registry.yarnpkg.com/simple-git/-/simple-git-3.28.0.tgz#c6345b2e387880f8450788a1e388573366ae48ac"
15886 + integrity sha512-Rs/vQRwsn1ILH1oBUy8NucJlXmnnLeLCfcvbSehkPzbv3wwoFWIdtfd6Ndo6ZPhlPsCZ60CPI4rxurnwAa+a2w==
15887 + dependencies:
15888 + "@kwsites/file-exists" "^1.1.1"
15889 + "@kwsites/promise-deferred" "^1.1.1"
15890 + debug "^4.4.0"
15891 +
15892 sisteransi@^1.0.5:
15893 version "1.0.5"
15894 resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
@@ -16067,7 +16230,7 @@ string-natural-compare@^3.0.1:
16230 resolved "https://registry.yarnpkg.com/string-natural-compare/-/string-natural-compare-3.0.1.tgz#7a42d58474454963759e8e8b7ae63d71c1e7fdf4"
16231 integrity sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==
16232
16070 -"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
16233 +"string-width-cjs@npm:string-width@^4.2.0":
16234 version "4.2.3"
16235 resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
16236 integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -16102,6 +16265,15 @@ string-width@^4.0.0:
16265 is-fullwidth-code-point "^3.0.0"
16266 strip-ansi "^6.0.0"
16267
16268 +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
16269 + version "4.2.3"
16270 + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
16271 + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
16272 + dependencies:
16273 + emoji-regex "^8.0.0"
16274 + is-fullwidth-code-point "^3.0.0"
16275 + strip-ansi "^6.0.1"
16276 +
16277 string-width@^5.0.1, string-width@^5.1.2:
16278 version "5.1.2"
16279 resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
@@ -16162,7 +16334,7 @@ string_decoder@~1.1.1:
16334 dependencies:
16335 safe-buffer "~5.1.0"
16336
16165 -"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1:
16337 +"strip-ansi-cjs@npm:strip-ansi@^6.0.1":
16338 version "6.0.1"
16339 resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
16340 integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
@@ -16190,6 +16362,13 @@ strip-ansi@^5.1.0:
16362 dependencies:
16363 ansi-regex "^4.1.0"
16364
16365 +strip-ansi@^6.0.0, strip-ansi@^6.0.1:
16366 + version "6.0.1"
16367 + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
16368 + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
16369 + dependencies:
16370 + ansi-regex "^5.0.1"
16371 +
16372 strip-ansi@^7.0.1:
16373 version "7.1.0"
16374 resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
@@ -16424,6 +16603,17 @@ table@^6.0.9:
16603 string-width "^4.2.3"
16604 strip-ansi "^6.0.1"
16605
16606 +table@^6.7.3:
16607 + version "6.9.0"
16608 + resolved "https://registry.yarnpkg.com/table/-/table-6.9.0.tgz#50040afa6264141c7566b3b81d4d82c47a8668f5"
16609 + integrity sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==
16610 + dependencies:
16611 + ajv "^8.0.1"
16612 + lodash.truncate "^4.4.2"
16613 + slice-ansi "^4.0.0"
16614 + string-width "^4.2.3"
16615 + strip-ansi "^6.0.1"
16616 +
16617 tapable@^2.1.1, tapable@^2.2.0, tapable@^2.2.1:
16618 version "2.2.1"
16619 resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
@@ -16925,6 +17115,11 @@ typedarray@^0.0.6:
17115 resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
17116 integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
17117
17118 +typescript-compiler@^1.4.1-2:
17119 + version "1.4.1-2"
17120 + resolved "https://registry.yarnpkg.com/typescript-compiler/-/typescript-compiler-1.4.1-2.tgz#ba4f7db22d91534a1929d90009dce161eb72fd3f"
17121 + integrity sha512-EMopKmoAEJqA4XXRFGOb7eSBhmQMbBahW6P1Koayeatp0b4AW2q/bBqYWkpG7QVQc9HGQUiS4trx2ZHcnAaZUg==
17122 +
17123 typescript@3.9.3:
17124 version "3.9.3"
17125 resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.3.tgz#d3ac8883a97c26139e42df5e93eeece33d610b8a"
@@ -16935,6 +17130,11 @@ typescript@^5.4.3:
17130 resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.3.tgz#919b44a7dbb8583a9b856d162be24a54bf80073e"
17131 integrity sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==
17132
17133 +typescript@~4.4.4:
17134 + version "4.4.4"
17135 + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.4.4.tgz#2cd01a1a1f160704d3101fd5a58ff0f9fcb8030c"
17136 + integrity sha512-DqGhF5IKoBl8WNf8C1gu8q0xZSInh9j1kJJMqT3a94w1JzVaBU4EXOSMrz9yDqMT0xt3selp83fuFMQ0uzv6qA==
17137 +
17138 ua-parser-js@^0.7.18, ua-parser-js@^0.7.9:
17139 version "0.7.20"
17140 resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.20.tgz#7527178b82f6a62a0f243d1f94fd30e3e3c21098"
@@ -17772,7 +17972,7 @@ workerize-loader@^2.0.2:
17972 dependencies:
17973 loader-utils "^2.0.0"
17974
17775 -"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
17975 +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
17976 version "7.0.0"
17977 resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
17978 integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
@@ -17790,6 +17990,15 @@ wrap-ansi@^6.2.0:
17990 string-width "^4.1.0"
17991 strip-ansi "^6.0.0"
17992
17993 +wrap-ansi@^7.0.0:
17994 + version "7.0.0"
17995 + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
17996 + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
17997 + dependencies:
17998 + ansi-styles "^4.0.0"
17999 + string-width "^4.1.0"
18000 + strip-ansi "^6.0.0"
18001 +
18002 wrap-ansi@^8.1.0:
18003 version "8.1.0"
18004 resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
@@ -17945,6 +18154,14 @@ yargs-parser@^18.1.1:
18154 camelcase "^5.0.0"
18155 decamelize "^1.2.0"
18156
18157 +yargs-parser@^18.1.2:
18158 + version "18.1.3"
18159 + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0"
18160 + integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==
18161 + dependencies:
18162 + camelcase "^5.0.0"
18163 + decamelize "^1.2.0"
18164 +
18165 yargs-parser@^21.1.1:
18166 version "21.1.1"
18167 resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
@@ -17963,6 +18180,23 @@ yargs@17.7.2, yargs@^17.3.1:
18180 y18n "^5.0.5"
18181 yargs-parser "^21.1.1"
18182
18183 +yargs@^15.1.0:
18184 + version "15.4.1"
18185 + resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8"
18186 + integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==
18187 + dependencies:
18188 + cliui "^6.0.0"
18189 + decamelize "^1.2.0"
18190 + find-up "^4.1.0"
18191 + get-caller-file "^2.0.1"
18192 + require-directory "^2.1.1"
18193 + require-main-filename "^2.0.0"
18194 + set-blocking "^2.0.0"
18195 + string-width "^4.2.0"
18196 + which-module "^2.0.0"
18197 + y18n "^4.0.0"
18198 + yargs-parser "^18.1.2"
18199 +
18200 yargs@^15.3.1:
18201 version "15.3.1"
18202 resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.3.1.tgz#9505b472763963e54afe60148ad27a330818e98b"