diff --git a/.eslintignore b/.eslintignore index c30542a3f7e2c..fd9cc6bdca2fe 100644 --- a/.eslintignore +++ b/.eslintignore @@ -28,3 +28,6 @@ packages/react-devtools-shared/src/hooks/__tests__/__source__/__untransformed__/ packages/react-devtools-shell/dist packages/react-devtools-timeline/dist packages/react-devtools-timeline/static + +# Imported third-party Flow types +flow-typed/ diff --git a/.eslintrc.js b/.eslintrc.js index e219e428d2480..82abfbe632e21 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -581,6 +581,7 @@ module.exports = { IteratorResult: 'readonly', JSONValue: 'readonly', JSResourceReference: 'readonly', + mixin$Animatable: 'readonly', MouseEventHandler: 'readonly', NavigateEvent: 'readonly', PropagationPhases: 'readonly', @@ -619,7 +620,6 @@ module.exports = { PropertyIndexedKeyframes: 'readonly', KeyframeAnimationOptions: 'readonly', GetAnimationsOptions: 'readonly', - Animatable: 'readonly', ScrollTimeline: 'readonly', EventListenerOptionsOrUseCapture: 'readonly', FocusOptions: 'readonly', diff --git a/compiler/package.json b/compiler/package.json index e3c3ee8c7f341..4492b70210803 100644 --- a/compiler/package.json +++ b/compiler/package.json @@ -19,7 +19,8 @@ "test": "yarn workspaces run test", "snap": "yarn workspace babel-plugin-react-compiler run snap", "snap:build": "yarn workspace snap run build", - "npm:publish": "node scripts/release/publish" + "npm:publish": "node scripts/release/publish", + "eslint-docs": "yarn workspace babel-plugin-react-compiler build && node scripts/build-eslint-docs.js" }, "dependencies": { "fs-extra": "^4.0.2", diff --git a/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts b/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts index 5940dbb4fd6ba..964217c399317 100644 --- a/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts +++ b/compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts @@ -7,9 +7,10 @@ import * as t from '@babel/types'; import {codeFrameColumns} from '@babel/code-frame'; -import type {SourceLocation} from './HIR'; +import {type SourceLocation} from './HIR'; import {Err, Ok, Result} from './Utils/Result'; import {assertExhaustive} from './Utils/utils'; +import invariant from 'invariant'; export enum ErrorSeverity { /** @@ -628,7 +629,18 @@ export type LintRule = { recommended: boolean; }; +const RULE_NAME_PATTERN = /^[a-z]+(-[a-z]+)*$/; + export function getRuleForCategory(category: ErrorCategory): LintRule { + const rule = getRuleForCategoryImpl(category); + invariant( + RULE_NAME_PATTERN.test(rule.name), + `Invalid rule name, got '${rule.name}' but rules must match ${RULE_NAME_PATTERN.toString()}`, + ); + return rule; +} + +function getRuleForCategoryImpl(category: ErrorCategory): LintRule { switch (category) { case ErrorCategory.AutomaticEffectDependencies: { return { @@ -636,7 +648,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { name: 'automatic-effect-dependencies', description: 'Verifies that automatic effect dependencies are compiled if opted-in', - recommended: true, + recommended: false, }; } case ErrorCategory.CapitalizedCalls: { @@ -652,7 +664,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { return { category, name: 'config', - description: 'Validates the configuration', + description: 'Validates the compiler configuration options', recommended: true, }; } @@ -678,7 +690,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'set-state-in-effect', description: - 'Validates against calling setState synchronously in an effect', + 'Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance', recommended: true, }; } @@ -687,7 +699,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'error-boundaries', description: - 'Validates usage of error boundaries instead of try/catch for errors in JSX', + 'Validates usage of error boundaries instead of try/catch for errors in child components', recommended: true, }; } @@ -711,7 +723,8 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { return { category, name: 'gating', - description: 'Validates configuration of gating mode', + description: + 'Validates configuration of [gating mode](https://react.dev/reference/react-compiler/gating)', recommended: true, }; } @@ -720,7 +733,8 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'globals', description: - 'Validates against assignment/mutation of globals during render', + 'Validates against assignment/mutation of globals during render, part of ensuring that ' + + '[side effects must render outside of render](https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)', recommended: true, }; } @@ -742,7 +756,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'immutability', description: - 'Validates that immutable values (props, state, etc) are not mutated', + 'Validates against mutating props, state, and other values that [are immutable](https://react.dev/reference/rules/components-and-hooks-must-be-pure#props-and-state-are-immutable)', recommended: true, }; } @@ -759,7 +773,9 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'preserve-manual-memoization', description: - 'Validates that existing manual memoized is preserved by the compiler', + 'Validates that existing manual memoized is preserved by the compiler. ' + + 'React Compiler will only compile components and hooks if its inference ' + + '[matches or exceeds the existing manual memoization](https://react.dev/learn/react-compiler/introduction#what-should-i-do-about-usememo-usecallback-and-reactmemo)', recommended: true, }; } @@ -768,7 +784,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'purity', description: - 'Validates that the component/hook is pure, and does not call known-impure functions', + 'Validates that [components/hooks are pure](https://react.dev/reference/rules/components-and-hooks-must-be-pure) by checking that they do not call known-impure functions', recommended: true, }; } @@ -777,7 +793,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'refs', description: - 'Validates correct usage of refs, not reading/writing during render', + 'Validates correct usage of refs, not reading/writing during render. See the "pitfalls" section in [`useRef()` usage](https://react.dev/reference/react/useRef#usage)', recommended: true, }; } @@ -785,7 +801,8 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { return { category, name: 'set-state-in-render', - description: 'Validates against setting state during render', + description: + 'Validates against setting state during render, which can trigger additional renders and potential infinite render loops', recommended: true, }; } @@ -794,7 +811,7 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { category, name: 'static-components', description: - 'Validates that components are static, not recreated every render', + 'Validates that components are static, not recreated every render. Components that are recreated dynamically can reset state and trigger excessive re-rendering', recommended: true, }; } @@ -826,7 +843,8 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { return { category, name: 'unsupported-syntax', - description: 'Validates against syntax that we do not plan to support', + description: + 'Validates against syntax that we do not plan to support in React Compiler', recommended: true, }; } @@ -834,7 +852,8 @@ export function getRuleForCategory(category: ErrorCategory): LintRule { return { category, name: 'use-memo', - description: 'Validates usage of the useMemo() hook', + description: + 'Validates usage of the useMemo() hook against common mistakes. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.', recommended: true, }; } diff --git a/compiler/scripts/build-eslint-docs.js b/compiler/scripts/build-eslint-docs.js new file mode 100644 index 0000000000000..d8d59096d9ea6 --- /dev/null +++ b/compiler/scripts/build-eslint-docs.js @@ -0,0 +1,32 @@ +const ReactCompiler = require('../packages/babel-plugin-react-compiler/dist'); + +const combinedRules = [ + { + name: 'rules-of-hooks', + recommended: true, + description: + 'Validates that components and hooks follow the [Rules of Hooks](https://react.dev/reference/rules/rules-of-hooks)', + }, + { + name: 'exhaustive-deps', + recommended: true, + description: + 'Validates that hooks which accept dependency arrays (`useMemo()`, `useCallback()`, `useEffect()`, etc) ' + + 'list all referenced variables in their dependency array. Referencing a value without including it in the ' + + 'dependency array can lead to stale UI or callbacks.', + }, + ...ReactCompiler.LintRules, +]; + +const printed = combinedRules + .filter(rule => rule.recommended) + .map(rule => { + return ` +## \`react-hooks/${rule.name}\` + +${rule.description} + `.trim(); + }) + .join('\n\n'); + +console.log(printed); diff --git a/flow-typed.config.json b/flow-typed.config.json new file mode 100644 index 0000000000000..10b200008371b --- /dev/null +++ b/flow-typed.config.json @@ -0,0 +1,20 @@ +{ + "env": [ + "bom", + "cssom", + "dom", + "geometry", + "html", + "node", + "serviceworkers", + "streams", + "web-animations" + ], + "ignore": [ + "create-react-class", + "jest", + "regenerator-runtime", + "webpack", + "ws" + ] +} diff --git a/flow-typed/environments/bom.js b/flow-typed/environments/bom.js new file mode 100644 index 0000000000000..06412856009d4 --- /dev/null +++ b/flow-typed/environments/bom.js @@ -0,0 +1,2719 @@ +// flow-typed signature: 09630545c584c3b212588a2390c257d0 +// flow-typed version: baae4b8bcc/bom/flow_>=v0.261.x + +/* BOM */ + +declare class Screen { + +availHeight: number; + +availWidth: number; + +availLeft: number; + +availTop: number; + +top: number; + +left: number; + +colorDepth: number; + +pixelDepth: number; + +width: number; + +height: number; + +orientation?: { + lock(): Promise, + unlock(): void, + angle: number, + onchange: () => mixed, + type: + | 'portrait-primary' + | 'portrait-secondary' + | 'landscape-primary' + | 'landscape-secondary', + ... + }; + // deprecated + mozLockOrientation?: (orientation: string | Array) => boolean; + mozUnlockOrientation?: () => void; + mozOrientation?: string; + onmozorientationchange?: (...args: any[]) => mixed; +} + +declare var screen: Screen; + +declare interface Crypto { + // Not using $TypedArray as that would include Float32Array and Float64Array which are not accepted + getRandomValues: < + T: + | Int8Array + | Uint8Array + | Uint8ClampedArray + | Int16Array + | Uint16Array + | Int32Array + | Uint32Array + | BigInt64Array + | BigUint64Array, + >( + typedArray: T + ) => T; + randomUUID: () => string; +} +declare var crypto: Crypto; + +declare var window: any; + +type GamepadButton = { + pressed: boolean, + value: number, + ... +}; +type GamepadHapticActuator = { + type: 'vibration', + pulse(value: number, duration: number): Promise, + ... +}; +type GamepadPose = { + angularAcceleration: null | Float32Array, + angularVelocity: null | Float32Array, + hasOrientation: boolean, + hasPosition: boolean, + linearAcceleration: null | Float32Array, + linearVelocity: null | Float32Array, + orientation: null | Float32Array, + position: null | Float32Array, + ... +}; +type Gamepad = { + axes: number[], + buttons: GamepadButton[], + connected: boolean, + displayId?: number, + hapticActuators?: GamepadHapticActuator[], + hand?: '' | 'left' | 'right', + id: string, + index: number, + mapping: string, + pose?: null | GamepadPose, + timestamp: number, + ... +}; + +// deprecated +type BatteryManager = { + +charging: boolean, + +chargingTime: number, + +dischargingTime: number, + +level: number, + onchargingchange: ?(event: any) => mixed, + onchargingtimechange: ?(event: any) => mixed, + ondischargingtimechange: ?(event: any) => mixed, + onlevelchange: ?(event: any) => mixed, + ... +}; + +// https://wicg.github.io/web-share +type ShareData = { + title?: string, + text?: string, + url?: string, + ... +}; + +type PermissionName = + | 'geolocation' + | 'notifications' + | 'push' + | 'midi' + | 'camera' + | 'microphone' + | 'speaker' + | 'usb' + | 'device-info' + | 'background-sync' + | 'bluetooth' + | 'persistent-storage' + | 'ambient-light-sensor' + | 'accelerometer' + | 'gyroscope' + | 'magnetometer' + | 'clipboard-read' + | 'clipboard-write'; + +type PermissionState = 'granted' | 'denied' | 'prompt'; + +type PermissionDescriptor = {| + name: PermissionName, +|}; + +type DevicePermissionDescriptor = {| + deviceId?: string, + name: 'camera' | 'microphone' | 'speaker', +|}; + +type MidiPermissionDescriptor = {| + name: 'midi', + sysex?: boolean, +|}; + +type PushPermissionDescriptor = {| + name: 'push', + userVisibleOnly?: boolean, +|}; + +type ClipboardPermissionDescriptor = {| + name: 'clipboard-read' | 'clipboard-write', + allowWithoutGesture: boolean, +|}; + +type USBPermissionDescriptor = {| + name: 'usb', + filters: Array, + exclusionFilters: Array, +|}; + +type FileSystemHandlePermissionDescriptor = {| + mode: 'read' | 'readwrite', +|}; + +declare class PermissionStatus extends EventTarget { + onchange: ?(event: any) => mixed; + +state: PermissionState; +} + +declare class Permissions { + query( + permissionDesc: + | DevicePermissionDescriptor + | MidiPermissionDescriptor + | PushPermissionDescriptor + | ClipboardPermissionDescriptor + | USBPermissionDescriptor + | PermissionDescriptor + ): Promise; +} + +type MIDIPortType = 'input' | 'output'; +type MIDIPortDeviceState = 'connected' | 'disconnected'; +type MIDIPortConnectionState = 'open' | 'closed' | 'pending'; + +type MIDIOptions = {| + sysex: boolean, + software: boolean, +|}; + +type MIDIMessageEvent$Init = Event$Init & { + data: Uint8Array, + ... +}; + +declare class MIDIMessageEvent extends Event { + constructor(type: string, eventInitDict: MIDIMessageEvent$Init): void; + +data: Uint8Array; +} + +type MIDIConnectionEvent$Init = Event$Init & { + port: MIDIPort, + ... +}; + +declare class MIDIConnectionEvent extends Event { + constructor(type: string, eventInitDict: MIDIConnectionEvent$Init): void; + +port: MIDIPort; +} + +declare class MIDIPort extends EventTarget { + +id: string; + +manufacturer?: string; + +name?: string; + +type: MIDIPortType; + +version?: string; + +state: MIDIPortDeviceState; + +connection: MIDIPortConnectionState; + onstatechange: ?(ev: MIDIConnectionEvent) => mixed; + open(): Promise; + close(): Promise; +} + +declare class MIDIInput extends MIDIPort { + onmidimessage: ?(ev: MIDIMessageEvent) => mixed; +} + +declare class MIDIOutput extends MIDIPort { + send(data: Iterable, timestamp?: number): void; + clear(): void; +} + +declare class MIDIInputMap extends $ReadOnlyMap {} + +declare class MIDIOutputMap extends $ReadOnlyMap {} + +declare class MIDIAccess extends EventTarget { + +inputs: MIDIInputMap; + +outputs: MIDIOutputMap; + +sysexEnabled: boolean; + onstatechange: ?(ev: MIDIConnectionEvent) => mixed; +} + +declare class NavigatorID { + appName: 'Netscape'; + appCodeName: 'Mozilla'; + product: 'Gecko'; + appVersion: string; + platform: string; + userAgent: string; +} + +declare class NavigatorLanguage { + +language: string; + +languages: $ReadOnlyArray; +} + +declare class NavigatorContentUtils { + registerContentHandler(mimeType: string, uri: string, title: string): void; + registerProtocolHandler(protocol: string, uri: string, title: string): void; +} + +declare class NavigatorCookies { + +cookieEnabled: boolean; +} + +declare class NavigatorPlugins { + +plugins: PluginArray; + +mimeTypes: MimeTypeArray; + javaEnabled(): boolean; +} + +declare class NavigatorOnLine { + +onLine: boolean; +} + +declare class NavigatorConcurrentHardware { + +hardwareConcurrency: number; +} + +declare class NavigatorStorage { + storage?: StorageManager; +} + +declare class StorageManager { + persist: () => Promise; + persisted: () => Promise; + estimate?: () => Promise; + getDirectory: () => Promise; +} + +type StorageManagerRegisteredEndpoint = + | 'caches' + | 'indexedDB' + | 'localStorage' + | 'serviceWorkerRegistrations' + | 'sessionStorage'; + +type StorageManagerUsageDetails = {[StorageManagerRegisteredEndpoint]: number}; + +declare class StorageEstimate { + constructor( + usage: number, + quota: number, + usageDetails?: StorageManagerUsageDetails + ): void; + +usage: number; + +quota: number; + + // Not a part of the standard + +usageDetails?: StorageManagerUsageDetails; +} + +declare class Navigator + mixins + NavigatorID, + NavigatorLanguage, + NavigatorOnLine, + NavigatorContentUtils, + NavigatorCookies, + NavigatorPlugins, + NavigatorConcurrentHardware, + NavigatorStorage +{ + productSub: '20030107' | '20100101'; + vendor: '' | 'Google Inc.' | 'Apple Computer, Inc'; + vendorSub: ''; + + activeVRDisplays?: VRDisplay[]; + appCodeName: 'Mozilla'; + buildID: string; + doNotTrack: string | null; + geolocation: Geolocation; + mediaDevices?: MediaDevices; + usb?: USB; + maxTouchPoints: number; + permissions: Permissions; + serviceWorker?: ServiceWorkerContainer; + getGamepads?: () => Array; + webkitGetGamepads?: Function; + mozGetGamepads?: Function; + mozGamepads?: any; + gamepads?: any; + webkitGamepads?: any; + getVRDisplays?: () => Promise; + registerContentHandler(mimeType: string, uri: string, title: string): void; + registerProtocolHandler(protocol: string, uri: string, title: string): void; + requestMIDIAccess?: (options?: MIDIOptions) => Promise; + requestMediaKeySystemAccess?: ( + keySystem: string, + supportedConfigurations: any[] + ) => Promise; + sendBeacon?: (url: string, data?: BodyInit) => boolean; + vibrate?: (pattern: number | number[]) => boolean; + mozVibrate?: (pattern: number | number[]) => boolean; + webkitVibrate?: (pattern: number | number[]) => boolean; + canShare?: (shareData?: ShareData) => boolean; + share?: (shareData: ShareData) => Promise; + clipboard: Clipboard; + credentials?: CredMgmtCredentialsContainer; + globalPrivacyControl?: boolean; + + // deprecated + getBattery?: () => Promise; + mozGetBattery?: () => Promise; + + // deprecated + getUserMedia?: Function; + webkitGetUserMedia?: Function; + mozGetUserMedia?: Function; + msGetUserMedia?: Function; + + // Gecko + taintEnabled?: () => false; + oscpu: string; +} + +declare class Clipboard extends EventTarget { + read(): Promise; + readText(): Promise; + write(data: $ReadOnlyArray): Promise; + writeText(data: string): Promise; +} + +declare var navigator: Navigator; + +declare class MimeType { + type: string; + description: string; + suffixes: string; + enabledPlugin: Plugin; +} + +declare class MimeTypeArray { + length: number; + item(index: number): MimeType; + namedItem(name: string): MimeType; + [key: number | string]: MimeType; +} + +declare class Plugin { + description: string; + filename: string; + name: string; + version?: string; // Gecko only + length: number; + item(index: number): MimeType; + namedItem(name: string): MimeType; + [key: number | string]: MimeType; +} + +declare class PluginArray { + length: number; + item(index: number): Plugin; + namedItem(name: string): Plugin; + refresh(): void; + [key: number | string]: Plugin; +} + +// https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp +// https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp +declare type DOMHighResTimeStamp = number; + +// https://www.w3.org/TR/navigation-timing-2/ +declare class PerformanceTiming { + connectEnd: number; + connectStart: number; + domainLookupEnd: number; + domainLookupStart: number; + domComplete: number; + domContentLoadedEventEnd: number; + domContentLoadedEventStart: number; + domInteractive: number; + domLoading: number; + fetchStart: number; + loadEventEnd: number; + loadEventStart: number; + navigationStart: number; + redirectEnd: number; + redirectStart: number; + requestStart: number; + responseEnd: number; + responseStart: number; + secureConnectionStart: number; + unloadEventEnd: number; + unloadEventStart: number; +} + +declare class PerformanceNavigation { + TYPE_NAVIGATE: 0; + TYPE_RELOAD: 1; + TYPE_BACK_FORWARD: 2; + TYPE_RESERVED: 255; + + type: 0 | 1 | 2 | 255; + redirectCount: number; +} + +type PerformanceEntryFilterOptions = { + name: string, + entryType: string, + initiatorType: string, + ... +}; + +// https://www.w3.org/TR/performance-timeline-2/ +declare class PerformanceEntry { + name: string; + entryType: string; + startTime: DOMHighResTimeStamp; + duration: DOMHighResTimeStamp; + toJSON(): string; +} + +// https://w3c.github.io/server-timing/#the-performanceservertiming-interface +declare class PerformanceServerTiming { + description: string; + duration: DOMHighResTimeStamp; + name: string; + toJSON(): string; +} + +// https://www.w3.org/TR/resource-timing-2/#sec-performanceresourcetiming +// https://w3c.github.io/server-timing/#extension-to-the-performanceresourcetiming-interface +declare class PerformanceResourceTiming extends PerformanceEntry { + initiatorType: string; + nextHopProtocol: string; + workerStart: number; + redirectStart: number; + redirectEnd: number; + fetchStart: number; + domainLookupStart: number; + domainLookupEnd: number; + connectStart: number; + connectEnd: number; + secureConnectionStart: number; + requestStart: number; + responseStart: number; + responseEnd: number; + transferSize: string; + encodedBodySize: number; + decodedBodySize: number; + serverTiming: Array; +} + +// https://w3c.github.io/event-timing/#sec-performance-event-timing +declare class PerformanceEventTiming extends PerformanceEntry { + processingStart: number; + processingEnd: number; + cancelable: boolean; + target: ?Node; + interactionId: number; +} + +// https://w3c.github.io/longtasks/#taskattributiontiming +declare class TaskAttributionTiming extends PerformanceEntry { + containerType: string; + containerSrc: string; + containerId: string; + containerName: string; +} + +// https://w3c.github.io/longtasks/#sec-PerformanceLongTaskTiming +declare class PerformanceLongTaskTiming extends PerformanceEntry { + attribution: $ReadOnlyArray; +} + +// https://www.w3.org/TR/navigation-timing-2/ +declare class PerformanceNavigationTiming extends PerformanceResourceTiming { + unloadEventStart: number; + unloadEventEnd: number; + domInteractive: number; + domContentLoadedEventStart: number; + domContentLoadedEventEnd: number; + domComplete: number; + loadEventStart: number; + loadEventEnd: number; + type: 'navigate' | 'reload' | 'back_forward' | 'prerender'; + redirectCount: number; +} + +// https://www.w3.org/TR/user-timing/#extensions-performance-interface +declare type PerformanceMarkOptions = {| + detail?: mixed, + startTime?: number, +|}; + +declare type PerformanceMeasureOptions = {| + detail?: mixed, + start?: number | string, + end?: number | string, + duration?: number, +|}; + +type EventCountsForEachCallbackType = + | (() => void) + | ((value: number) => void) + | ((value: number, key: string) => void) + | ((value: number, key: string, map: Map) => void); + +// https://www.w3.org/TR/event-timing/#eventcounts +declare interface EventCounts { + size: number; + + entries(): Iterator<[string, number]>; + forEach(callback: EventCountsForEachCallbackType): void; + get(key: string): ?number; + has(key: string): boolean; + keys(): Iterator; + values(): Iterator; +} + +declare class Performance { + eventCounts: EventCounts; + + // deprecated + navigation: PerformanceNavigation; + timing: PerformanceTiming; + + onresourcetimingbufferfull: (ev: any) => mixed; + clearMarks(name?: string): void; + clearMeasures(name?: string): void; + clearResourceTimings(): void; + getEntries(options?: PerformanceEntryFilterOptions): Array; + getEntriesByName(name: string, type?: string): Array; + getEntriesByType(type: string): Array; + mark(name: string, options?: PerformanceMarkOptions): void; + measure( + name: string, + startMarkOrOptions?: string | PerformanceMeasureOptions, + endMark?: string + ): void; + now(): DOMHighResTimeStamp; + setResourceTimingBufferSize(maxSize: number): void; + toJSON(): string; +} + +declare var performance: Performance; + +type PerformanceEntryList = PerformanceEntry[]; + +declare interface PerformanceObserverEntryList { + getEntries(): PerformanceEntryList; + getEntriesByType(type: string): PerformanceEntryList; + getEntriesByName(name: string, type: ?string): PerformanceEntryList; +} + +type PerformanceObserverInit = { + entryTypes?: string[], + type?: string, + buffered?: boolean, + ... +}; + +declare class PerformanceObserver { + constructor( + callback: ( + entries: PerformanceObserverEntryList, + observer: PerformanceObserver + ) => mixed + ): void; + + observe(options: ?PerformanceObserverInit): void; + disconnect(): void; + takeRecords(): PerformanceEntryList; + + static supportedEntryTypes: string[]; +} + +declare class History { + length: number; + scrollRestoration: 'auto' | 'manual'; + state: any; + back(): void; + forward(): void; + go(delta?: number): void; + pushState(statedata: any, title: string, url?: string): void; + replaceState(statedata: any, title: string, url?: string): void; +} + +declare var history: History; + +declare class Location { + ancestorOrigins: string[]; + hash: string; + host: string; + hostname: string; + href: string; + origin: string; + pathname: string; + port: string; + protocol: string; + search: string; + assign(url: string): void; + reload(flag?: boolean): void; + replace(url: string): void; + toString(): string; +} + +declare var location: Location; + +/////////////////////////////////////////////////////////////////////////////// + +declare class DOMParser { + parseFromString(source: string | TrustedHTML, mimeType: string): Document; +} + +type FormDataEntryValue = string | File; + +declare class FormData { + constructor(form?: HTMLFormElement, submitter?: HTMLElement | null): void; + + has(name: string): boolean; + get(name: string): ?FormDataEntryValue; + getAll(name: string): Array; + + set(name: string, value: string): void; + set(name: string, value: Blob, filename?: string): void; + set(name: string, value: File, filename?: string): void; + + append(name: string, value: string): void; + append(name: string, value: Blob, filename?: string): void; + append(name: string, value: File, filename?: string): void; + + delete(name: string): void; + + keys(): Iterator; + values(): Iterator; + entries(): Iterator<[string, FormDataEntryValue]>; +} + +declare type IntersectionObserverEntry = { + boundingClientRect: DOMRectReadOnly, + intersectionRatio: number, + intersectionRect: DOMRectReadOnly, + isIntersecting: boolean, + rootBounds: DOMRectReadOnly, + target: Element, + time: DOMHighResTimeStamp, + ... +}; + +declare type IntersectionObserverCallback = ( + entries: Array, + observer: IntersectionObserver +) => mixed; + +declare type IntersectionObserverOptions = { + root?: Node | null, + rootMargin?: string, + threshold?: number | Array, + ... +}; + +declare class IntersectionObserver { + constructor( + callback: IntersectionObserverCallback, + options?: IntersectionObserverOptions + ): void; + root: Element | null; + rootMargin: string; + scrollMargin: string; + thresholds: number[]; + observe(target: Element): void; + unobserve(target: Element): void; + takeRecords(): Array; + disconnect(): void; +} + +declare interface ResizeObserverSize { + +inlineSize: number; + +blockSize: number; +} + +declare interface ResizeObserverEntry { + /** + * The Element whose size has changed. + */ + +target: Element; + /** + * Element's content rect when ResizeObserverCallback is invoked. + * + * Legacy, may be deprecated in the future. + */ + +contentRect: DOMRectReadOnly; + /** + * An array containing the Element's border box size when + * ResizeObserverCallback is invoked. + */ + +borderBoxSize: $ReadOnlyArray; + /** + * An array containing the Element's content rect size when + * ResizeObserverCallback is invoked. + */ + +contentBoxSize: $ReadOnlyArray; + /** + * An array containing the Element's content rect size in integral device + * pixels when ResizeObserverCallback is invoked. + * + * Not implemented in Firefox or Safari as of July 2021 + */ + +devicePixelContentBoxSize?: $ReadOnlyArray | void; +} + +/** + * ResizeObserver can observe different kinds of CSS sizes: + * - border-box : size of box border area as defined in CSS2. + * - content-box : size of content area as defined in CSS2. + * - device-pixel-content-box : size of content area as defined in CSS2, in device + * pixels, before applying any CSS transforms on the element or its ancestors. + * This size must contain integer values. + */ +type ResizeObserverBoxOptions = + | 'border-box' + | 'content-box' + | 'device-pixel-content-box'; + +declare type ResizeObserverOptions = { + box?: ResizeObserverBoxOptions, + ... +}; + +/** + * The ResizeObserver interface is used to observe changes to Element's size. + */ +declare class ResizeObserver { + constructor( + callback: ( + entries: ResizeObserverEntry[], + observer: ResizeObserver + ) => mixed + ): void; + /** + * Adds target to the list of observed elements. + */ + observe(target: Element, options?: ResizeObserverOptions): void; + /** + * Removes target from the list of observed elements. + */ + unobserve(target: Element): void; + disconnect(): void; +} + +declare class CloseEvent extends Event { + code: number; + reason: string; + wasClean: boolean; +} + +declare class WebSocket extends EventTarget { + static CONNECTING: 0; + static OPEN: 1; + static CLOSING: 2; + static CLOSED: 3; + constructor(url: string, protocols?: string | Array): void; + protocol: string; + readyState: number; + bufferedAmount: number; + extensions: string; + onopen: (ev: any) => mixed; + onmessage: (ev: MessageEvent) => mixed; + onclose: (ev: CloseEvent) => mixed; + onerror: (ev: any) => mixed; + binaryType: 'blob' | 'arraybuffer'; + url: string; + close(code?: number, reason?: string): void; + send(data: string): void; + send(data: Blob): void; + send(data: ArrayBuffer): void; + send(data: $ArrayBufferView): void; + CONNECTING: 0; + OPEN: 1; + CLOSING: 2; + CLOSED: 3; +} + +type WorkerOptions = { + type?: WorkerType, + credentials?: CredentialsType, + name?: string, + ... +}; + +declare class Worker extends EventTarget { + constructor( + stringUrl: string | TrustedScriptURL, + workerOptions?: WorkerOptions + ): void; + onerror: null | ((ev: any) => mixed); + onmessage: null | ((ev: MessageEvent) => mixed); + onmessageerror: null | ((ev: MessageEvent) => mixed); + postMessage(message: any, ports?: any): void; + terminate(): void; +} + +declare class SharedWorker extends EventTarget { + constructor(stringUrl: string | TrustedScriptURL, name?: string): void; + constructor( + stringUrl: string | TrustedScriptURL, + workerOptions?: WorkerOptions + ): void; + port: MessagePort; + onerror: (ev: any) => mixed; +} + +declare function importScripts(...urls: Array): void; + +declare class WorkerGlobalScope extends EventTarget { + self: this; + location: WorkerLocation; + navigator: WorkerNavigator; + close(): void; + importScripts(...urls: Array): void; + onerror: (ev: any) => mixed; + onlanguagechange: (ev: any) => mixed; + onoffline: (ev: any) => mixed; + ononline: (ev: any) => mixed; + onrejectionhandled: (ev: PromiseRejectionEvent) => mixed; + onunhandledrejection: (ev: PromiseRejectionEvent) => mixed; +} + +declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope { + onmessage: (ev: MessageEvent) => mixed; + onmessageerror: (ev: MessageEvent) => mixed; + postMessage(message: any, transfer?: Iterable): void; +} + +declare class SharedWorkerGlobalScope extends WorkerGlobalScope { + name: string; + onconnect: (ev: MessageEvent) => mixed; +} + +declare class WorkerLocation { + origin: string; + protocol: string; + host: string; + hostname: string; + port: string; + pathname: string; + search: string; + hash: string; +} + +declare class WorkerNavigator + mixins + NavigatorID, + NavigatorLanguage, + NavigatorOnLine, + NavigatorConcurrentHardware, + NavigatorStorage +{ + permissions: Permissions; +} + +// deprecated +declare class XDomainRequest { + timeout: number; + onerror: () => mixed; + onload: () => mixed; + onprogress: () => mixed; + ontimeout: () => mixed; + +responseText: string; + +contentType: string; + open(method: 'GET' | 'POST', url: string): void; + abort(): void; + send(data?: string): void; + + statics: {create(): XDomainRequest, ...}; +} + +declare class XMLHttpRequest extends EventTarget { + static LOADING: number; + static DONE: number; + static UNSENT: number; + static OPENED: number; + static HEADERS_RECEIVED: number; + responseBody: any; + status: number; + readyState: number; + responseText: string; + responseXML: any; + responseURL: string; + ontimeout: ProgressEventHandler; + statusText: string; + onreadystatechange: (ev: any) => mixed; + timeout: number; + onload: ProgressEventHandler; + response: any; + withCredentials: boolean; + onprogress: ProgressEventHandler; + onabort: ProgressEventHandler; + responseType: string; + onloadend: ProgressEventHandler; + upload: XMLHttpRequestEventTarget; + onerror: ProgressEventHandler; + onloadstart: ProgressEventHandler; + msCaching: string; + open( + method: string, + url: string, + async?: boolean, + user?: string, + password?: string + ): void; + send(data?: any): void; + abort(): void; + getAllResponseHeaders(): string; + setRequestHeader(header: string, value: string): void; + getResponseHeader(header: string): string; + msCachingEnabled(): boolean; + overrideMimeType(mime: string): void; + LOADING: number; + DONE: number; + UNSENT: number; + OPENED: number; + HEADERS_RECEIVED: number; + + statics: {create(): XMLHttpRequest, ...}; +} + +declare class XMLHttpRequestEventTarget extends EventTarget { + onprogress: ProgressEventHandler; + onerror: ProgressEventHandler; + onload: ProgressEventHandler; + ontimeout: ProgressEventHandler; + onabort: ProgressEventHandler; + onloadstart: ProgressEventHandler; + onloadend: ProgressEventHandler; +} + +declare class XMLSerializer { + serializeToString(target: Node): string; +} + +declare class Geolocation { + getCurrentPosition( + success: (position: Position) => mixed, + error?: (error: PositionError) => mixed, + options?: PositionOptions + ): void; + watchPosition( + success: (position: Position) => mixed, + error?: (error: PositionError) => mixed, + options?: PositionOptions + ): number; + clearWatch(id: number): void; +} + +declare class Position { + coords: Coordinates; + timestamp: number; +} + +declare class Coordinates { + latitude: number; + longitude: number; + altitude?: number; + accuracy: number; + altitudeAccuracy?: number; + heading?: number; + speed?: number; +} + +declare class PositionError { + code: number; + message: string; + PERMISSION_DENIED: 1; + POSITION_UNAVAILABLE: 2; + TIMEOUT: 3; +} + +type PositionOptions = { + enableHighAccuracy?: boolean, + timeout?: number, + maximumAge?: number, + ... +}; + +type AudioContextState = 'suspended' | 'running' | 'closed'; + +// deprecated +type AudioProcessingEvent$Init = Event$Init & { + playbackTime: number, + inputBuffer: AudioBuffer, + outputBuffer: AudioBuffer, + ... +}; + +// deprecated +declare class AudioProcessingEvent extends Event { + constructor(type: string, eventInitDict: AudioProcessingEvent$Init): void; + + +playbackTime: number; + +inputBuffer: AudioBuffer; + +outputBuffer: AudioBuffer; +} + +type OfflineAudioCompletionEvent$Init = Event$Init & { + renderedBuffer: AudioBuffer, + ... +}; + +declare class OfflineAudioCompletionEvent extends Event { + constructor( + type: string, + eventInitDict: OfflineAudioCompletionEvent$Init + ): void; + + +renderedBuffer: AudioBuffer; +} + +declare class BaseAudioContext extends EventTarget { + currentTime: number; + destination: AudioDestinationNode; + listener: AudioListener; + sampleRate: number; + state: AudioContextState; + onstatechange: (ev: any) => mixed; + createBuffer( + numOfChannels: number, + length: number, + sampleRate: number + ): AudioBuffer; + createBufferSource(myMediaElement?: HTMLMediaElement): AudioBufferSourceNode; + createMediaElementSource( + myMediaElement: HTMLMediaElement + ): MediaElementAudioSourceNode; + createMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode; + createMediaStreamDestination(): MediaStreamAudioDestinationNode; + + // deprecated + createScriptProcessor( + bufferSize: number, + numberOfInputChannels: number, + numberOfOutputChannels: number + ): ScriptProcessorNode; + + createAnalyser(): AnalyserNode; + createBiquadFilter(): BiquadFilterNode; + createChannelMerger(numberOfInputs?: number): ChannelMergerNode; + createChannelSplitter(numberOfInputs?: number): ChannelSplitterNode; + createConstantSource(): ConstantSourceNode; + createConvolver(): ConvolverNode; + createDelay(maxDelayTime?: number): DelayNode; + createDynamicsCompressor(): DynamicsCompressorNode; + createGain(): GainNode; + createIIRFilter( + feedforward: Float32Array, + feedback: Float32Array + ): IIRFilterNode; + createOscillator(): OscillatorNode; + createPanner(): PannerNode; + createStereoPanner(): StereoPannerNode; + createPeriodicWave( + real: Float32Array, + img: Float32Array, + options?: {disableNormalization: boolean, ...} + ): PeriodicWave; + createStereoPanner(): StereoPannerNode; + createWaveShaper(): WaveShaperNode; + decodeAudioData( + arrayBuffer: ArrayBuffer, + decodeSuccessCallback: (decodedData: AudioBuffer) => mixed, + decodeErrorCallback: (err: DOMError) => mixed + ): void; + decodeAudioData(arrayBuffer: ArrayBuffer): Promise; +} + +declare class AudioTimestamp { + contextTime: number; + performanceTime: number; +} + +declare class AudioContext extends BaseAudioContext { + constructor(options?: {| + latencyHint?: 'balanced' | 'interactive' | 'playback' | number, + sampleRate?: number, + |}): AudioContext; + baseLatency: number; + outputLatency: number; + getOutputTimestamp(): AudioTimestamp; + resume(): Promise; + suspend(): Promise; + close(): Promise; + createMediaElementSource( + myMediaElement: HTMLMediaElement + ): MediaElementAudioSourceNode; + createMediaStreamSource( + myMediaStream: MediaStream + ): MediaStreamAudioSourceNode; + createMediaStreamTrackSource( + myMediaStreamTrack: MediaStreamTrack + ): MediaStreamTrackAudioSourceNode; + createMediaStreamDestination(): MediaStreamAudioDestinationNode; +} + +declare class OfflineAudioContext extends BaseAudioContext { + startRendering(): Promise; + suspend(suspendTime: number): Promise; + length: number; + oncomplete: (ev: OfflineAudioCompletionEvent) => mixed; +} + +declare class AudioNode extends EventTarget { + context: AudioContext; + numberOfInputs: number; + numberOfOutputs: number; + channelCount: number; + channelCountMode: 'max' | 'clamped-max' | 'explicit'; + channelInterpretation: 'speakers' | 'discrete'; + connect(audioNode: AudioNode, output?: number, input?: number): AudioNode; + connect(destination: AudioParam, output?: number): void; + disconnect(destination?: AudioNode, output?: number, input?: number): void; +} + +declare class AudioParam extends AudioNode { + value: number; + defaultValue: number; + setValueAtTime(value: number, startTime: number): this; + linearRampToValueAtTime(value: number, endTime: number): this; + exponentialRampToValueAtTime(value: number, endTime: number): this; + setTargetAtTime( + target: number, + startTime: number, + timeConstant: number + ): this; + setValueCurveAtTime( + values: Float32Array, + startTime: number, + duration: number + ): this; + cancelScheduledValues(startTime: number): this; +} + +declare class AudioDestinationNode extends AudioNode { + maxChannelCount: number; +} + +declare class AudioListener extends AudioNode { + positionX: AudioParam; + positionY: AudioParam; + positionZ: AudioParam; + forwardX: AudioParam; + forwardY: AudioParam; + forwardZ: AudioParam; + upX: AudioParam; + upY: AudioParam; + upZ: AudioParam; + setPosition(x: number, y: number, c: number): void; + setOrientation( + x: number, + y: number, + z: number, + xUp: number, + yUp: number, + zUp: number + ): void; +} + +declare class AudioBuffer { + sampleRate: number; + length: number; + duration: number; + numberOfChannels: number; + getChannelData(channel: number): Float32Array; + copyFromChannel( + destination: Float32Array, + channelNumber: number, + startInChannel?: number + ): void; + copyToChannel( + source: Float32Array, + channelNumber: number, + startInChannel?: number + ): void; +} + +declare class AudioBufferSourceNode extends AudioNode { + buffer: AudioBuffer; + detune: AudioParam; + loop: boolean; + loopStart: number; + loopEnd: number; + playbackRate: AudioParam; + onended: (ev: any) => mixed; + start(when?: number, offset?: number, duration?: number): void; + stop(when?: number): void; +} + +declare class CanvasCaptureMediaStream extends MediaStream { + canvas: HTMLCanvasElement; + requestFrame(): void; +} + +type DoubleRange = { + max?: number, + min?: number, + ... +}; + +type LongRange = { + max?: number, + min?: number, + ... +}; + +type ConstrainBooleanParameters = { + exact?: boolean, + ideal?: boolean, + ... +}; + +type ConstrainDOMStringParameters = { + exact?: string | string[], + ideal?: string | string[], + ... +}; + +type ConstrainDoubleRange = { + ...DoubleRange, + exact?: number, + ideal?: number, + ... +}; + +type ConstrainLongRange = { + ...LongRange, + exact?: number, + ideal?: number, + ... +}; + +type MediaTrackSupportedConstraints = {| + width: boolean, + height: boolean, + aspectRatio: boolean, + frameRate: boolean, + facingMode: boolean, + resizeMode: boolean, + volume: boolean, + sampleRate: boolean, + sampleSize: boolean, + echoCancellation: boolean, + autoGainControl: boolean, + noiseSuppression: boolean, + latency: boolean, + channelCount: boolean, + deviceId: boolean, + groupId: boolean, +|}; + +type MediaTrackConstraintSet = { + width?: number | ConstrainLongRange, + height?: number | ConstrainLongRange, + aspectRatio?: number | ConstrainDoubleRange, + frameRate?: number | ConstrainDoubleRange, + facingMode?: string | string[] | ConstrainDOMStringParameters, + resizeMode?: string | string[] | ConstrainDOMStringParameters, + volume?: number | ConstrainDoubleRange, + sampleRate?: number | ConstrainLongRange, + sampleSize?: number | ConstrainLongRange, + echoCancellation?: boolean | ConstrainBooleanParameters, + autoGainControl?: boolean | ConstrainBooleanParameters, + noiseSuppression?: boolean | ConstrainBooleanParameters, + latency?: number | ConstrainDoubleRange, + channelCount?: number | ConstrainLongRange, + deviceId?: string | string[] | ConstrainDOMStringParameters, + groupId?: string | string[] | ConstrainDOMStringParameters, + ... +}; + +type MediaTrackConstraints = { + ...MediaTrackConstraintSet, + advanced?: Array, + ... +}; + +type DisplayMediaStreamConstraints = { + video?: boolean | MediaTrackConstraints, + audio?: boolean | MediaTrackConstraints, + ... +}; + +type MediaStreamConstraints = { + audio?: boolean | MediaTrackConstraints, + video?: boolean | MediaTrackConstraints, + peerIdentity?: string, + ... +}; + +type MediaTrackSettings = { + aspectRatio?: number, + deviceId?: string, + displaySurface?: 'application' | 'browser' | 'monitor' | 'window', + echoCancellation?: boolean, + facingMode?: string, + frameRate?: number, + groupId?: string, + height?: number, + logicalSurface?: boolean, + sampleRate?: number, + sampleSize?: number, + volume?: number, + width?: number, + ... +}; + +type MediaTrackCapabilities = { + aspectRatio?: number | DoubleRange, + deviceId?: string, + echoCancellation?: boolean[], + facingMode?: string, + frameRate?: number | DoubleRange, + groupId?: string, + height?: number | LongRange, + sampleRate?: number | LongRange, + sampleSize?: number | LongRange, + volume?: number | DoubleRange, + width?: number | LongRange, + ... +}; + +declare class MediaDevices extends EventTarget { + ondevicechange: (ev: any) => mixed; + enumerateDevices: () => Promise>; + getSupportedConstraints: () => MediaTrackSupportedConstraints; + getDisplayMedia: ( + constraints?: DisplayMediaStreamConstraints + ) => Promise; + getUserMedia: (constraints: MediaStreamConstraints) => Promise; +} + +declare class MediaDeviceInfo { + +deviceId: string; + +groupId: string; + +kind: 'videoinput' | 'audioinput' | 'audiooutput'; + +label: string; +} + +type MediaRecorderOptions = { + mimeType?: string, + audioBitsPerSecond?: number, + videoBitsPerSecond?: number, + bitsPerSecond?: number, + audioBitrateMode?: 'cbr' | 'vbr', + ... +}; + +declare class MediaRecorder extends EventTarget { + constructor(stream: MediaStream, options?: MediaRecorderOptions): void; + +stream: MediaStream; + +mimeType: string; + +state: 'inactive' | 'recording' | 'paused'; + + onstart: (ev: any) => mixed; + onstop: (ev: any) => mixed; + ondataavailable: (ev: any) => mixed; + onpause: (ev: any) => mixed; + onresume: (ev: any) => mixed; + onerror: (ev: any) => mixed; + + +videoBitsPerSecond: number; + +audioBitsPerSecond: number; + +audioBitrateMode: 'cbr' | 'vbr'; + + start(timeslice?: number): void; + stop(): void; + pause(): void; + resume(): void; + requestData(): void; + + static isTypeSupported(type: string): boolean; +} + +declare class MediaStream extends EventTarget { + active: boolean; + ended: boolean; + id: string; + onactive: (ev: any) => mixed; + oninactive: (ev: any) => mixed; + onended: (ev: any) => mixed; + onaddtrack: (ev: MediaStreamTrackEvent) => mixed; + onremovetrack: (ev: MediaStreamTrackEvent) => mixed; + addTrack(track: MediaStreamTrack): void; + clone(): MediaStream; + getAudioTracks(): MediaStreamTrack[]; + getTrackById(trackid?: string): ?MediaStreamTrack; + getTracks(): MediaStreamTrack[]; + getVideoTracks(): MediaStreamTrack[]; + removeTrack(track: MediaStreamTrack): void; +} + +declare class MediaStreamTrack extends EventTarget { + enabled: boolean; + id: string; + kind: string; + label: string; + muted: boolean; + readonly: boolean; + readyState: 'live' | 'ended'; + remote: boolean; + contentHint?: string; + onstarted: (ev: any) => mixed; + onmute: (ev: any) => mixed; + onunmute: (ev: any) => mixed; + onoverconstrained: (ev: any) => mixed; + onended: (ev: any) => mixed; + getConstraints(): MediaTrackConstraints; + applyConstraints(constraints?: MediaTrackConstraints): Promise; + getSettings(): MediaTrackSettings; + getCapabilities(): MediaTrackCapabilities; + clone(): MediaStreamTrack; + stop(): void; +} + +declare class MediaStreamTrackEvent extends Event { + track: MediaStreamTrack; +} + +declare class MediaElementAudioSourceNode extends AudioNode {} +declare class MediaStreamAudioSourceNode extends AudioNode {} +declare class MediaStreamTrackAudioSourceNode extends AudioNode {} + +declare class MediaStreamAudioDestinationNode extends AudioNode { + stream: MediaStream; +} + +// deprecated +declare class ScriptProcessorNode extends AudioNode { + bufferSize: number; + onaudioprocess: (ev: AudioProcessingEvent) => mixed; +} + +declare class AnalyserNode extends AudioNode { + fftSize: number; + frequencyBinCount: number; + minDecibels: number; + maxDecibels: number; + smoothingTimeConstant: number; + getFloatFrequencyData(array: Float32Array): Float32Array; + getByteFrequencyData(array: Uint8Array): Uint8Array; + getFloatTimeDomainData(array: Float32Array): Float32Array; + getByteTimeDomainData(array: Uint8Array): Uint8Array; +} + +declare class BiquadFilterNode extends AudioNode { + frequency: AudioParam; + detune: AudioParam; + Q: AudioParam; + gain: AudioParam; + type: + | 'lowpass' + | 'highpass' + | 'bandpass' + | 'lowshelf' + | 'highshelf' + | 'peaking' + | 'notch' + | 'allpass'; + getFrequencyResponse( + frequencyHz: Float32Array, + magResponse: Float32Array, + phaseResponse: Float32Array + ): void; +} + +declare class ChannelMergerNode extends AudioNode {} +declare class ChannelSplitterNode extends AudioNode {} + +type ConstantSourceOptions = {offset?: number, ...}; +declare class ConstantSourceNode extends AudioNode { + constructor(context: BaseAudioContext, options?: ConstantSourceOptions): void; + offset: AudioParam; + onended: (ev: any) => mixed; + start(when?: number): void; + stop(when?: number): void; +} + +declare class ConvolverNode extends AudioNode { + buffer: AudioBuffer; + normalize: boolean; +} + +declare class DelayNode extends AudioNode { + delayTime: number; +} + +declare class DynamicsCompressorNode extends AudioNode { + threshold: AudioParam; + knee: AudioParam; + ratio: AudioParam; + reduction: AudioParam; + attack: AudioParam; + release: AudioParam; +} + +declare class GainNode extends AudioNode { + gain: AudioParam; +} + +declare class IIRFilterNode extends AudioNode { + getFrequencyResponse( + frequencyHz: Float32Array, + magResponse: Float32Array, + phaseResponse: Float32Array + ): void; +} + +declare class OscillatorNode extends AudioNode { + frequency: AudioParam; + detune: AudioParam; + type: 'sine' | 'square' | 'sawtooth' | 'triangle' | 'custom'; + start(when?: number): void; + stop(when?: number): void; + setPeriodicWave(periodicWave: PeriodicWave): void; + onended: (ev: any) => mixed; +} + +declare class StereoPannerNode extends AudioNode { + pan: AudioParam; +} + +declare class PannerNode extends AudioNode { + panningModel: 'equalpower' | 'HRTF'; + distanceModel: 'linear' | 'inverse' | 'exponential'; + refDistance: number; + maxDistance: number; + rolloffFactor: number; + coneInnerAngle: number; + coneOuterAngle: number; + coneOuterGain: number; + setPosition(x: number, y: number, z: number): void; + setOrientation(x: number, y: number, z: number): void; +} + +declare class PeriodicWave extends AudioNode {} +declare class WaveShaperNode extends AudioNode { + curve: Float32Array; + oversample: 'none' | '2x' | '4x'; +} + +// this part of spec is not finished yet, apparently +// https://stackoverflow.com/questions/35296664/can-fetch-get-object-as-headers +type HeadersInit = + | Headers + | Array<[string, string]> + | {[key: string]: string, ...}; + +// TODO Heades and URLSearchParams are almost the same thing. +// Could it somehow be abstracted away? +declare class Headers { + @@iterator(): Iterator<[string, string]>; + constructor(init?: HeadersInit): void; + append(name: string, value: string): void; + delete(name: string): void; + entries(): Iterator<[string, string]>; + forEach( + callback: ( + this: This, + value: string, + name: string, + headers: Headers + ) => mixed, + thisArg: This + ): void; + get(name: string): null | string; + has(name: string): boolean; + keys(): Iterator; + set(name: string, value: string): void; + values(): Iterator; +} + +declare class URLSearchParams { + @@iterator(): Iterator<[string, string]>; + + size: number; + + constructor( + init?: + | string + | URLSearchParams + | Array<[string, string]> + | {[string]: string, ...} + ): void; + append(name: string, value: string): void; + delete(name: string, value?: string): void; + entries(): Iterator<[string, string]>; + forEach( + callback: ( + this: This, + value: string, + name: string, + params: URLSearchParams + ) => mixed, + thisArg: This + ): void; + get(name: string): null | string; + getAll(name: string): Array; + has(name: string, value?: string): boolean; + keys(): Iterator; + set(name: string, value: string): void; + sort(): void; + values(): Iterator; + toString(): string; +} + +type CacheType = + | 'default' + | 'no-store' + | 'reload' + | 'no-cache' + | 'force-cache' + | 'only-if-cached'; +type CredentialsType = 'omit' | 'same-origin' | 'include'; +type ModeType = 'cors' | 'no-cors' | 'same-origin' | 'navigate'; +type RedirectType = 'follow' | 'error' | 'manual'; +type ReferrerPolicyType = + | '' + | 'no-referrer' + | 'no-referrer-when-downgrade' + | 'same-origin' + | 'origin' + | 'strict-origin' + | 'origin-when-cross-origin' + | 'strict-origin-when-cross-origin' + | 'unsafe-url'; + +type ResponseType = + | 'basic' + | 'cors' + | 'default' + | 'error' + | 'opaque' + | 'opaqueredirect'; + +type BodyInit = + | string + | URLSearchParams + | FormData + | Blob + | ArrayBuffer + | $ArrayBufferView + | ReadableStream; + +type RequestInfo = Request | URL | string; + +type RequestOptions = { + body?: ?BodyInit, + cache?: CacheType, + credentials?: CredentialsType, + headers?: HeadersInit, + integrity?: string, + keepalive?: boolean, + method?: string, + mode?: ModeType, + redirect?: RedirectType, + referrer?: string, + referrerPolicy?: ReferrerPolicyType, + signal?: ?AbortSignal, + window?: any, + ... +}; + +type ResponseOptions = { + status?: number, + statusText?: string, + headers?: HeadersInit, + ... +}; + +declare class Response { + constructor(input?: ?BodyInit, init?: ResponseOptions): void; + clone(): Response; + static error(): Response; + static redirect(url: string, status?: number): Response; + + redirected: boolean; + type: ResponseType; + url: string; + ok: boolean; + status: number; + statusText: string; + headers: Headers; + trailer: Promise; + + // Body methods and attributes + bodyUsed: boolean; + body: ?ReadableStream; + + arrayBuffer(): Promise; + blob(): Promise; + formData(): Promise; + json(): Promise; + text(): Promise; +} + +declare class Request { + constructor(input: RequestInfo, init?: RequestOptions): void; + clone(): Request; + + url: string; + + cache: CacheType; + credentials: CredentialsType; + headers: Headers; + integrity: string; + method: string; + mode: ModeType; + redirect: RedirectType; + referrer: string; + referrerPolicy: ReferrerPolicyType; + +signal: AbortSignal; + + // Body methods and attributes + bodyUsed: boolean; + + arrayBuffer(): Promise; + blob(): Promise; + formData(): Promise; + json(): Promise; + text(): Promise; +} + +declare function fetch( + input: RequestInfo, + init?: RequestOptions +): Promise; + +type TextEncoder$availableEncodings = + | 'utf-8' + | 'utf8' + | 'unicode-1-1-utf-8' + | 'utf-16be' + | 'utf-16' + | 'utf-16le'; + +declare class TextEncoder { + constructor(encoding?: TextEncoder$availableEncodings): void; + encode(buffer: string, options?: {stream: boolean, ...}): Uint8Array; + encoding: TextEncoder$availableEncodings; +} + +type TextDecoder$availableEncodings = + | '866' + | 'ansi_x3.4-1968' + | 'arabic' + | 'ascii' + | 'asmo-708' + | 'big5-hkscs' + | 'big5' + | 'chinese' + | 'cn-big5' + | 'cp1250' + | 'cp1251' + | 'cp1252' + | 'cp1253' + | 'cp1254' + | 'cp1255' + | 'cp1256' + | 'cp1257' + | 'cp1258' + | 'cp819' + | 'cp866' + | 'csbig5' + | 'cseuckr' + | 'cseucpkdfmtjapanese' + | 'csgb2312' + | 'csibm866' + | 'csiso2022jp' + | 'csiso2022kr' + | 'csiso58gb231280' + | 'csiso88596e' + | 'csiso88596i' + | 'csiso88598e' + | 'csiso88598i' + | 'csisolatin1' + | 'csisolatin2' + | 'csisolatin3' + | 'csisolatin4' + | 'csisolatin5' + | 'csisolatin6' + | 'csisolatin9' + | 'csisolatinarabic' + | 'csisolatincyrillic' + | 'csisolatingreek' + | 'csisolatinhebrew' + | 'cskoi8r' + | 'csksc56011987' + | 'csmacintosh' + | 'csshiftjis' + | 'cyrillic' + | 'dos-874' + | 'ecma-114' + | 'ecma-118' + | 'elot_928' + | 'euc-jp' + | 'euc-kr' + | 'gb_2312-80' + | 'gb_2312' + | 'gb18030' + | 'gb2312' + | 'gbk' + | 'greek' + | 'greek8' + | 'hebrew' + | 'hz-gb-2312' + | 'ibm819' + | 'ibm866' + | 'iso_8859-1:1987' + | 'iso_8859-1' + | 'iso_8859-2:1987' + | 'iso_8859-2' + | 'iso_8859-3:1988' + | 'iso_8859-3' + | 'iso_8859-4:1988' + | 'iso_8859-4' + | 'iso_8859-5:1988' + | 'iso_8859-5' + | 'iso_8859-6:1987' + | 'iso_8859-6' + | 'iso_8859-7:1987' + | 'iso_8859-7' + | 'iso_8859-8:1988' + | 'iso_8859-8' + | 'iso_8859-9:1989' + | 'iso_8859-9' + | 'iso-2022-cn-ext' + | 'iso-2022-cn' + | 'iso-2022-jp' + | 'iso-2022-kr' + | 'iso-8859-1' + | 'iso-8859-10' + | 'iso-8859-11' + | 'iso-8859-13' + | 'iso-8859-14' + | 'iso-8859-15' + | 'iso-8859-16' + | 'iso-8859-2' + | 'iso-8859-3' + | 'iso-8859-4' + | 'iso-8859-5' + | 'iso-8859-6-e' + | 'iso-8859-6-i' + | 'iso-8859-6' + | 'iso-8859-7' + | 'iso-8859-8-e' + | 'iso-8859-8-i' + | 'iso-8859-8' + | 'iso-8859-9' + | 'iso-ir-100' + | 'iso-ir-101' + | 'iso-ir-109' + | 'iso-ir-110' + | 'iso-ir-126' + | 'iso-ir-127' + | 'iso-ir-138' + | 'iso-ir-144' + | 'iso-ir-148' + | 'iso-ir-149' + | 'iso-ir-157' + | 'iso-ir-58' + | 'iso8859-1' + | 'iso8859-10' + | 'iso8859-11' + | 'iso8859-13' + | 'iso8859-14' + | 'iso8859-15' + | 'iso8859-2' + | 'iso8859-3' + | 'iso8859-4' + | 'iso8859-6' + | 'iso8859-7' + | 'iso8859-8' + | 'iso8859-9' + | 'iso88591' + | 'iso885910' + | 'iso885911' + | 'iso885913' + | 'iso885914' + | 'iso885915' + | 'iso88592' + | 'iso88593' + | 'iso88594' + | 'iso88595' + | 'iso88596' + | 'iso88597' + | 'iso88598' + | 'iso88599' + | 'koi' + | 'koi8_r' + | 'koi8-r' + | 'koi8-u' + | 'koi8' + | 'korean' + | 'ks_c_5601-1987' + | 'ks_c_5601-1989' + | 'ksc_5601' + | 'ksc5601' + | 'l1' + | 'l2' + | 'l3' + | 'l4' + | 'l5' + | 'l6' + | 'l9' + | 'latin1' + | 'latin2' + | 'latin3' + | 'latin4' + | 'latin5' + | 'latin6' + | 'latin9' + | 'logical' + | 'mac' + | 'macintosh' + | 'ms_kanji' + | 'shift_jis' + | 'shift-jis' + | 'sjis' + | 'sun_eu_greek' + | 'tis-620' + | 'unicode-1-1-utf-8' + | 'us-ascii' + | 'utf-16' + | 'utf-16be' + | 'utf-16le' + | 'utf-8' + | 'utf8' + | 'visual' + | 'windows-1250' + | 'windows-1251' + | 'windows-1252' + | 'windows-1253' + | 'windows-1254' + | 'windows-1255' + | 'windows-1256' + | 'windows-1257' + | 'windows-1258' + | 'windows-31j' + | 'windows-874' + | 'windows-949' + | 'x-cp1250' + | 'x-cp1251' + | 'x-cp1252' + | 'x-cp1253' + | 'x-cp1254' + | 'x-cp1255' + | 'x-cp1256' + | 'x-cp1257' + | 'x-cp1258' + | 'x-euc-jp' + | 'x-gbk' + | 'x-mac-cyrillic' + | 'x-mac-roman' + | 'x-mac-ukrainian' + | 'x-sjis' + | 'x-user-defined' + | 'x-x-big5'; + +declare class TextDecoder { + constructor( + encoding?: TextDecoder$availableEncodings, + options?: {fatal: boolean, ...} + ): void; + encoding: TextDecoder$availableEncodings; + fatal: boolean; + ignoreBOM: boolean; + decode( + buffer?: ArrayBuffer | $ArrayBufferView, + options?: {stream: boolean, ...} + ): string; +} + +declare class TextDecoderStream { + constructor( + encoding?: TextDecoder$availableEncodings, + options?: {fatal?: boolean, ignoreBOM?: boolean, ...} + ): void; + encoding: TextDecoder$availableEncodings; + fatal: boolean; + ignoreBOM: boolean; + readable: ReadableStream; + writable: WritableStream; +} + +declare class MessagePort extends EventTarget { + postMessage(message: any, transfer?: Iterable): void; + start(): void; + close(): void; + + onmessage: null | ((ev: MessageEvent) => mixed); + onmessageerror: null | ((ev: MessageEvent) => mixed); +} + +declare class MessageChannel { + port1: MessagePort; + port2: MessagePort; +} + +declare class VRDisplay extends EventTarget { + capabilities: VRDisplayCapabilities; + depthFar: number; + depthNear: number; + displayId: number; + displayName: string; + isPresenting: boolean; + stageParameters: null | VRStageParameters; + + cancelAnimationFrame(number): void; + exitPresent(): Promise; + getEyeParameters(VREye): VREyeParameters; + getFrameData(VRFrameData): boolean; + getLayers(): VRLayerInit[]; + requestAnimationFrame(cb: (number) => mixed): number; + requestPresent(VRLayerInit[]): Promise; + submitFrame(): void; +} + +type VRSource = HTMLCanvasElement; + +type VRLayerInit = { + leftBounds?: number[], + rightBounds?: number[], + source?: null | VRSource, + ... +}; + +type VRDisplayCapabilities = { + canPresent: boolean, + hasExternalDisplay: boolean, + hasPosition: boolean, + maxLayers: number, + ... +}; + +type VREye = 'left' | 'right'; + +type VRPose = { + angularAcceleration?: Float32Array, + angularVelocity?: Float32Array, + linearAcceleration?: Float32Array, + linearVelocity?: Float32Array, + orientation?: Float32Array, + position?: Float32Array, + ... +}; + +declare class VRFrameData { + leftProjectionMatrix: Float32Array; + leftViewMatrix: Float32Array; + pose: VRPose; + rightProjectionMatrix: Float32Array; + rightViewMatrix: Float32Array; + timestamp: number; +} + +type VREyeParameters = { + offset: Float32Array, + renderWidth: number, + renderHeight: number, + ... +}; + +type VRStageParameters = { + sittingToStandingTransform: Float32Array, + sizeX: number, + sizeZ: number, + ... +}; + +type VRDisplayEventReason = + | 'mounted' + | 'navigation' + | 'requested' + | 'unmounted'; + +type VRDisplayEventInit = { + display: VRDisplay, + reason: VRDisplayEventReason, + ... +}; + +declare class VRDisplayEvent extends Event { + constructor(type: string, eventInitDict: VRDisplayEventInit): void; + display: VRDisplay; + reason?: VRDisplayEventReason; +} + +declare class MediaQueryListEvent { + matches: boolean; + media: string; +} + +declare type MediaQueryListListener = (MediaQueryListEvent) => void; + +declare class MediaQueryList extends EventTarget { + matches: boolean; + media: string; + addListener: MediaQueryListListener => void; + removeListener: MediaQueryListListener => void; + onchange: MediaQueryListListener; +} + +declare var matchMedia: string => MediaQueryList; + +// https://w3c.github.io/webappsec-credential-management/#idl-index +declare type CredMgmtCredentialRequestOptions = { + mediation?: 'silent' | 'optional' | 'required', + signal?: AbortSignal, + ... +}; + +declare type CredMgmtCredentialCreationOptions = {signal: AbortSignal, ...}; + +declare interface CredMgmtCredential { + id: string; + type: string; +} + +declare interface CredMgmtPasswordCredential extends CredMgmtCredential { + password: string; +} + +declare interface CredMgmtCredentialsContainer { + get(option?: CredMgmtCredentialRequestOptions): Promise; + store(credential: CredMgmtCredential): Promise; + create( + creationOption?: CredMgmtCredentialCreationOptions + ): Promise; + preventSilentAccess(): Promise; +} + +type SpeechSynthesisErrorCode = + | 'canceled' + | 'interrupted' + | 'audio-busy' + | 'audio-hardware' + | 'network' + | 'synthesis-unavailable' + | 'synthesis-failed' + | 'language-unavailable' + | 'voice-unavailable' + | 'text-too-long' + | 'invalid-argument' + | 'not-allowed'; + +declare class SpeechSynthesis extends EventTarget { + +pending: boolean; + +speaking: boolean; + +paused: boolean; + + onvoiceschanged: ?(ev: Event) => mixed; + + speak(utterance: SpeechSynthesisUtterance): void; + cancel(): void; + pause(): void; + resume(): void; + getVoices(): Array; +} + +declare var speechSynthesis: SpeechSynthesis; + +declare class SpeechSynthesisUtterance extends EventTarget { + constructor(text?: string): void; + + text: string; + lang: string; + voice: SpeechSynthesisVoice | null; + volume: number; + rate: number; + pitch: number; + + onstart: ?(ev: SpeechSynthesisEvent) => mixed; + onend: ?(ev: SpeechSynthesisEvent) => mixed; + onerror: ?(ev: SpeechSynthesisErrorEvent) => mixed; + onpause: ?(ev: SpeechSynthesisEvent) => mixed; + onresume: ?(ev: SpeechSynthesisEvent) => mixed; + onmark: ?(ev: SpeechSynthesisEvent) => mixed; + onboundary: ?(ev: SpeechSynthesisEvent) => mixed; +} + +type SpeechSynthesisEvent$Init = Event$Init & { + utterance: SpeechSynthesisUtterance, + charIndex?: number, + charLength?: number, + elapsedTime?: number, + name?: string, + ... +}; + +declare class SpeechSynthesisEvent extends Event { + constructor(type: string, eventInitDict?: SpeechSynthesisEvent$Init): void; + + +utterance: SpeechSynthesisUtterance; + charIndex: number; + charLength: number; + elapsedTime: number; + name: string; +} + +type SpeechSynthesisErrorEvent$Init = SpeechSynthesisEvent$Init & { + error: SpeechSynthesisErrorCode, + ... +}; + +declare class SpeechSynthesisErrorEvent extends SpeechSynthesisEvent { + constructor( + type: string, + eventInitDict?: SpeechSynthesisErrorEvent$Init + ): void; + +error: SpeechSynthesisErrorCode; +} + +declare class SpeechSynthesisVoice { + +voiceURI: string; + +name: string; + +lang: string; + +localService: boolean; + +default: boolean; +} + +type SpeechRecognitionErrorCode = + | 'no-speech' + | 'aborted' + | 'audio-capture' + | 'not-allowed' + | 'service-not-allowed' + | 'bad-grammar' + | 'language-not-supported'; + +declare class SpeechGrammar { + constructor(): void; + + src: string; + weight?: number; +} + +declare class SpeechGrammarList { + +length: number; + + item(index: number): SpeechGrammar; + addFromURI(src: string, weight?: number): void; + addFromString(string: string, weight?: number): void; +} + +declare class SpeechRecognitionAlternative { + +transcript: string; + +confidence: number; +} + +declare class SpeechRecognitionResult { + +isFinal: boolean; + +length: number; + + item(index: number): SpeechRecognitionAlternative; +} + +declare class SpeechRecognitionResultList { + +length: number; + + item(index: number): SpeechRecognitionResult; +} + +type SpeechRecognitionEvent$Init = Event$Init & { + emma: any, + interpretation: any, + resultIndex: number, + results: SpeechRecognitionResultList, + ... +}; + +declare class SpeechRecognitionEvent extends Event { + constructor(type: string, eventInitDict?: SpeechRecognitionEvent$Init): void; + + +emma: any; + +interpretation: any; + +resultIndex: number; + +results: SpeechRecognitionResultList; +} + +type SpeechRecognitionErrorEvent$Init = SpeechRecognitionEvent$Init & { + error: SpeechRecognitionErrorCode, + ... +}; + +declare class SpeechRecognitionErrorEvent extends SpeechRecognitionEvent { + constructor( + type: string, + eventInitDict?: SpeechRecognitionErrorEvent$Init + ): void; + +error: SpeechRecognitionErrorCode; + +message: string; +} + +declare class SpeechRecognition extends EventTarget { + constructor(): void; + + +grammars: SpeechGrammar[]; + +lang: string; + +continuous: boolean; + +interimResults: boolean; + +maxAlternatives: number; + +serviceURI: string; + + onaudiostart: ?(ev: Event) => mixed; + onaudioend: ?(ev: Event) => mixed; + onend: ?(ev: Event) => mixed; + onerror: ?(ev: Event) => mixed; + onnomatch: ?(ev: Event) => mixed; + onsoundstart: ?(ev: Event) => mixed; + onsoundend: ?(ev: Event) => mixed; + onspeechstart: ?(ev: Event) => mixed; + onspeechend: ?(ev: Event) => mixed; + onstart: ?(ev: Event) => mixed; + + abort(): void; + start(): void; + stop(): void; +} + +/* Trusted Types + * https://w3c.github.io/trusted-types/dist/spec/#trusted-types + */ +declare class TrustedHTML { + toString(): string; + toJSON(): string; +} + +declare class TrustedScript { + toString(): string; + toJSON(): string; +} + +declare class TrustedScriptURL { + toString(): string; + toJSON(): string; +} + +declare class TrustedTypePolicy { + +name: string; + createHTML(input: string, ...args: Array): TrustedHTML; + createScript(input: string, ...args: Array): TrustedScript; + createScriptURL(input: string, ...args: Array): TrustedScriptURL; +} + +declare type TrustedTypePolicyOptions = {| + createHTML?: (string, ...args: Array) => string, + createScript?: (string, ...args: Array) => string, + createScriptURL?: (string, ...args: Array) => string, +|}; + +// window.trustedTypes?: TrustedTypePolicyFactory +declare class TrustedTypePolicyFactory { + +emptyHTML: TrustedHTML; + +emptyScript: TrustedScript; + +defaultPolicy: ?TrustedTypePolicy; + +isHTML: (value: mixed) => value is TrustedHTML; + +isScript: (value: mixed) => value is TrustedScript; + +isScriptURL: (value: mixed) => value is TrustedScriptURL; + createPolicy( + policyName: string, + policyOptions?: TrustedTypePolicyOptions + ): TrustedTypePolicy; + getAttributeType( + tagName: string, + attribute?: string, + elementNS?: string, + attrNS?: string + ): null | string; + getPropertyType( + tagName: string, + property: string, + elementNS?: string + ): null | string; +} + +// https://wicg.github.io/webusb/ +// https://developer.mozilla.org/en-US/docs/Web/API/USBDevice +declare class USBDevice { + configuration: USBConfiguration; + configurations: Array; + deviceClass: number; + deviceProtocol: number; + deviceSubclass: number; + deviceVersionMajor: number; + deviceVersionMinor: number; + deviceVersionSubminor: number; + manufacturerName: ?string; + opened: boolean; + productId: number; + productName: ?string; + serialNumber: ?string; + usbVersionMajor: number; + usbVersionMinor: number; + usbVersionSubminor: number; + vendorId: number; + claimInterface(interfaceNumber: number): Promise; + clearHalt(direction: 'in' | 'out', endpointNumber: number): Promise; + close(): Promise; + controlTransferIn( + setup: SetUpOptions, + length: number + ): Promise; + controlTransferOut( + setup: SetUpOptions, + data: ArrayBuffer + ): Promise; + forget(): Promise; + isochronousTransferIn( + endpointNumber: number, + packetLengths: Array + ): Promise; + isochronousTransferOut( + endpointNumber: number, + data: ArrayBuffer, + packetLengths: Array + ): Promise; + open(): Promise; + releaseInterface(interfaceNumber: number): Promise; + reset(): Promise; + selectAlternateInterface( + interfaceNumber: number, + alternateSetting: number + ): Promise; + selectConfiguration(configurationValue: number): Promise; + transferIn( + endpointNumber: number, + length: number + ): Promise; + transferOut( + endpointNumber: number, + data: ArrayBuffer + ): Promise; +} + +declare class USB extends EventTarget { + getDevices(): Promise>; + requestDevice(options: USBDeviceRequestOptions): Promise; +} + +declare type USBDeviceFilter = {| + vendorId?: number, + productId?: number, + classCode?: number, + subclassCode?: number, + protocolCode?: number, + serialNumber?: string, +|}; + +declare type USBDeviceRequestOptions = {| + filters: Array, + exclusionFilters?: Array, +|}; + +declare class USBConfiguration { + constructor(): void; + configurationName: ?string; + configurationValue: number; + interfaces: $ReadOnlyArray; +} + +declare class USBInterface { + constructor(): void; + interfaceNumber: number; + alternate: USBAlternateInterface; + alternates: Array; + claimed: boolean; +} + +declare class USBAlternateInterface { + constructor(): void; + alternateSetting: number; + interfaceClass: number; + interfaceSubclass: number; + interfaceProtocol: number; + interfaceName: ?string; + endpoints: Array; +} + +declare class USBEndpoint { + constructor(): void; + endpointNumber: number; + direction: 'in' | 'out'; + type: 'bulk' | 'interrupt' | 'isochronous'; + packetSize: number; +} + +declare class USBOutTransferResult { + constructor(): void; + bytesWritten: number; + status: 'ok' | 'stall'; +} + +declare class USBInTransferResult { + constructor(): void; + data: DataView; + status: 'ok' | 'stall' | 'babble'; +} + +declare class USBIsochronousInTransferResult { + constructor(): void; + data: DataView; + packets: Array; +} + +declare class USBIsochronousInTransferPacket { + constructor(): void; + data: DataView; + status: 'ok' | 'stall' | 'babble'; +} + +declare class USBIsochronousOutTransferResult { + constructor(): void; + packets: Array; +} + +declare class USBIsochronousOutTransferPacket { + constructor(): void; + bytesWritten: number; + status: 'ok' | 'stall'; +} + +type SetUpOptions = { + requestType: string, + recipient: string, + request: number, + value: number, + index: number, + ... +}; + +declare type FileSystemHandleKind = 'file' | 'directory'; + +// https://wicg.github.io/file-system-access/#api-filesystemhandle +declare class FileSystemHandle { + +kind: FileSystemHandleKind; + +name: string; + + isSameEntry: (other: FileSystemHandle) => Promise; + queryPermission?: ( + descriptor: FileSystemHandlePermissionDescriptor + ) => Promise; + requestPermission?: ( + descriptor: FileSystemHandlePermissionDescriptor + ) => Promise; +} + +// https://fs.spec.whatwg.org/#api-filesystemfilehandle +declare class FileSystemFileHandle extends FileSystemHandle { + +kind: 'file'; + + constructor(name: string): void; + + getFile(): Promise; + createSyncAccessHandle(): Promise; + createWritable(options?: {| + keepExistingData?: boolean, + |}): Promise; +} + +// https://fs.spec.whatwg.org/#api-filesystemdirectoryhandle +declare class FileSystemDirectoryHandle extends FileSystemHandle { + +kind: 'directory'; + + constructor(name: string): void; + + getDirectoryHandle( + name: string, + options?: {|create?: boolean|} + ): Promise; + getFileHandle( + name: string, + options?: {|create?: boolean|} + ): Promise; + removeEntry(name: string, options?: {|recursive?: boolean|}): Promise; + resolve(possibleDescendant: FileSystemHandle): Promise | null>; + + // Async iterator functions + @@asyncIterator(): AsyncIterator<[string, FileSystemHandle]>; + entries(): AsyncIterator<[string, FileSystemHandle]>; + keys(): AsyncIterator; + values(): AsyncIterator; +} + +// https://fs.spec.whatwg.org/#api-filesystemsyncaccesshandle +declare class FileSystemSyncAccessHandle { + close(): void; + flush(): void; + getSize(): number; + read(buffer: ArrayBuffer, options?: {|at: number|}): number; + truncate(newSize: number): void; + write(buffer: ArrayBuffer, options?: {|at: number|}): number; +} + +// https://streams.spec.whatwg.org/#default-writer-class +declare class WritableStreamDefaultWriter { + +closed: Promise; + +desiredSize: number; + +ready: Promise; + + constructor(): void; + + abort(reason?: string): Promise; + close(): Promise; + releaseLock(): void; + write(chunk: any): Promise; +} + +// https://streams.spec.whatwg.org/#ws-class +declare class WriteableStream { + +locked: boolean; + + constructor(): void; + + abort(reason: string): Promise; + close(): Promise; + getWriter(): WritableStreamDefaultWriter; +} + +// https://fs.spec.whatwg.org/#dictdef-writeparams +declare type FileSystemWriteableFileStreamDataTypes = + | ArrayBuffer + | $TypedArray + | DataView + | Blob + | string; + +// https://fs.spec.whatwg.org/#dictdef-writeparams +declare type FileSystemWriteableFileStreamData = + | FileSystemWriteableFileStreamDataTypes + | {| + type: 'write', + position?: number, + data: FileSystemWriteableFileStreamDataTypes, + |} + | {| + type: 'seek', + position: number, + data: FileSystemWriteableFileStreamDataTypes, + |} + | {| + type: 'size', + size: number, + |}; + +// https://fs.spec.whatwg.org/#api-filesystemwritablefilestream +declare class FileSystemWritableFileStream extends WriteableStream { + write(data: FileSystemWriteableFileStreamData): Promise; + truncate(size: number): Promise; + seek(position: number): Promise; +} diff --git a/flow-typed/environments/cssom.js b/flow-typed/environments/cssom.js new file mode 100644 index 0000000000000..c70a31cb70fea --- /dev/null +++ b/flow-typed/environments/cssom.js @@ -0,0 +1,414 @@ +// flow-typed signature: ad7b684aa8897ecb82bcc3e009b9fc30 +// flow-typed version: 3e51657e95/cssom/flow_>=v0.261.x + +declare class StyleSheet { + disabled: boolean; + +href: string; + +media: MediaList; + +ownerNode: Node; + +parentStyleSheet: ?StyleSheet; + +title: string; + +type: string; +} + +declare class StyleSheetList { + @@iterator(): Iterator; + length: number; + [index: number]: StyleSheet; +} + +declare class MediaList { + @@iterator(): Iterator; + mediaText: string; + length: number; + item(index: number): ?string; + deleteMedium(oldMedium: string): void; + appendMedium(newMedium: string): void; + [index: number]: string; +} + +declare class CSSStyleSheet extends StyleSheet { + +cssRules: CSSRuleList; + +ownerRule: ?CSSRule; + deleteRule(index: number): void; + insertRule(rule: string, index: number): number; + replace(text: string): Promise; + replaceSync(text: string): void; +} + +declare class CSSGroupingRule extends CSSRule { + +cssRules: CSSRuleList; + deleteRule(index: number): void; + insertRule(rule: string, index: number): number; +} + +declare class CSSConditionRule extends CSSGroupingRule { + conditionText: string; +} + +declare class CSSMediaRule extends CSSConditionRule { + +media: MediaList; +} + +declare class CSSStyleRule extends CSSRule { + selectorText: string; + +style: CSSStyleDeclaration; +} + +declare class CSSSupportsRule extends CSSConditionRule {} + +declare class CSSRule { + cssText: string; + +parentRule: ?CSSRule; + +parentStyleSheet: ?CSSStyleSheet; + +type: number; + static STYLE_RULE: number; + static MEDIA_RULE: number; + static FONT_FACE_RULE: number; + static PAGE_RULE: number; + static IMPORT_RULE: number; + static CHARSET_RULE: number; + static UNKNOWN_RULE: number; + static KEYFRAMES_RULE: number; + static KEYFRAME_RULE: number; + static NAMESPACE_RULE: number; + static COUNTER_STYLE_RULE: number; + static SUPPORTS_RULE: number; + static DOCUMENT_RULE: number; + static FONT_FEATURE_VALUES_RULE: number; + static VIEWPORT_RULE: number; + static REGION_STYLE_RULE: number; +} + +declare class CSSKeyframeRule extends CSSRule { + keyText: string; + +style: CSSStyleDeclaration; +} + +declare class CSSKeyframesRule extends CSSRule { + name: string; + +cssRules: CSSRuleList; + appendRule(rule: string): void; + deleteRule(select: string): void; + findRule(select: string): CSSKeyframeRule | null; +} + +declare class CSSRuleList { + @@iterator(): Iterator; + length: number; + item(index: number): ?CSSRule; + [index: number]: CSSRule; +} + +declare class CSSStyleDeclaration { + @@iterator(): Iterator; + /* DOM CSS Properties */ + alignContent: string; + alignItems: string; + alignSelf: string; + all: string; + animation: string; + animationDelay: string; + animationDirection: string; + animationDuration: string; + animationFillMode: string; + animationIterationCount: string; + animationName: string; + animationPlayState: string; + animationTimingFunction: string; + backdropFilter: string; + webkitBackdropFilter: string; + backfaceVisibility: string; + background: string; + backgroundAttachment: string; + backgroundBlendMode: string; + backgroundClip: string; + backgroundColor: string; + backgroundImage: string; + backgroundOrigin: string; + backgroundPosition: string; + backgroundPositionX: string; + backgroundPositionY: string; + backgroundRepeat: string; + backgroundSize: string; + blockSize: string; + border: string; + borderBlockEnd: string; + borderBlockEndColor: string; + borderBlockEndStyle: string; + borderBlockEndWidth: string; + borderBlockStart: string; + borderBlockStartColor: string; + borderBlockStartStyle: string; + borderBlockStartWidth: string; + borderBottom: string; + borderBottomColor: string; + borderBottomLeftRadius: string; + borderBottomRightRadius: string; + borderBottomStyle: string; + borderBottomWidth: string; + borderCollapse: string; + borderColor: string; + borderImage: string; + borderImageOutset: string; + borderImageRepeat: string; + borderImageSlice: string; + borderImageSource: string; + borderImageWidth: string; + borderInlineEnd: string; + borderInlineEndColor: string; + borderInlineEndStyle: string; + borderInlineEndWidth: string; + borderInlineStart: string; + borderInlineStartColor: string; + borderInlineStartStyle: string; + borderInlineStartWidth: string; + borderLeft: string; + borderLeftColor: string; + borderLeftStyle: string; + borderLeftWidth: string; + borderRadius: string; + borderRight: string; + borderRightColor: string; + borderRightStyle: string; + borderRightWidth: string; + borderSpacing: string; + borderStyle: string; + borderTop: string; + borderTopColor: string; + borderTopLeftRadius: string; + borderTopRightRadius: string; + borderTopStyle: string; + borderTopWidth: string; + borderWidth: string; + bottom: string; + boxDecorationBreak: string; + boxShadow: string; + boxSizing: string; + breakAfter: string; + breakBefore: string; + breakInside: string; + captionSide: string; + clear: string; + clip: string; + clipPath: string; + color: string; + columns: string; + columnCount: string; + columnFill: string; + columnGap: string; + columnRule: string; + columnRuleColor: string; + columnRuleStyle: string; + columnRuleWidth: string; + columnSpan: string; + columnWidth: string; + contain: string; + content: string; + counterIncrement: string; + counterReset: string; + cursor: string; + direction: string; + display: string; + emptyCells: string; + filter: string; + flex: string; + flexBasis: string; + flexDirection: string; + flexFlow: string; + flexGrow: string; + flexShrink: string; + flexWrap: string; + float: string; + font: string; + fontFamily: string; + fontFeatureSettings: string; + fontKerning: string; + fontLanguageOverride: string; + fontSize: string; + fontSizeAdjust: string; + fontStretch: string; + fontStyle: string; + fontSynthesis: string; + fontVariant: string; + fontVariantAlternates: string; + fontVariantCaps: string; + fontVariantEastAsian: string; + fontVariantLigatures: string; + fontVariantNumeric: string; + fontVariantPosition: string; + fontWeight: string; + grad: string; + grid: string; + gridArea: string; + gridAutoColumns: string; + gridAutoFlow: string; + gridAutoPosition: string; + gridAutoRows: string; + gridColumn: string; + gridColumnStart: string; + gridColumnEnd: string; + gridRow: string; + gridRowStart: string; + gridRowEnd: string; + gridTemplate: string; + gridTemplateAreas: string; + gridTemplateRows: string; + gridTemplateColumns: string; + height: string; + hyphens: string; + imageRendering: string; + imageResolution: string; + imageOrientation: string; + imeMode: string; + inherit: string; + initial: string; + inlineSize: string; + isolation: string; + justifyContent: string; + left: string; + letterSpacing: string; + lineBreak: string; + lineHeight: string; + listStyle: string; + listStyleImage: string; + listStylePosition: string; + listStyleType: string; + margin: string; + marginBlockEnd: string; + marginBlockStart: string; + marginBottom: string; + marginInlineEnd: string; + marginInlineStart: string; + marginLeft: string; + marginRight: string; + marginTop: string; + marks: string; + mask: string; + maskType: string; + maxBlockSize: string; + maxHeight: string; + maxInlineSize: string; + maxWidth: string; + minBlockSize: string; + minHeight: string; + minInlineSize: string; + minWidth: string; + mixBlendMode: string; + mozTransform: string; + mozTransformOrigin: string; + mozTransitionDelay: string; + mozTransitionDuration: string; + mozTransitionProperty: string; + mozTransitionTimingFunction: string; + objectFit: string; + objectPosition: string; + offsetBlockEnd: string; + offsetBlockStart: string; + offsetInlineEnd: string; + offsetInlineStart: string; + opacity: string; + order: string; + orphans: string; + outline: string; + outlineColor: string; + outlineOffset: string; + outlineStyle: string; + outlineWidth: string; + overflow: string; + overflowWrap: string; + overflowX: string; + overflowY: string; + padding: string; + paddingBlockEnd: string; + paddingBlockStart: string; + paddingBottom: string; + paddingInlineEnd: string; + paddingInlineStart: string; + paddingLeft: string; + paddingRight: string; + paddingTop: string; + pageBreakAfter: string; + pageBreakBefore: string; + pageBreakInside: string; + perspective: string; + perspectiveOrigin: string; + pointerEvents: string; + position: string; + quotes: string; + rad: string; + resize: string; + right: string; + rubyAlign: string; + rubyMerge: string; + rubyPosition: string; + scrollBehavior: string; + scrollSnapCoordinate: string; + scrollSnapDestination: string; + scrollSnapPointsX: string; + scrollSnapPointsY: string; + scrollSnapType: string; + shapeImageThreshold: string; + shapeMargin: string; + shapeOutside: string; + tableLayout: string; + tabSize: string; + textAlign: string; + textAlignLast: string; + textCombineUpright: string; + textDecoration: string; + textDecorationColor: string; + textDecorationLine: string; + textDecorationStyle: string; + textIndent: string; + textOrientation: string; + textOverflow: string; + textRendering: string; + textShadow: string; + textTransform: string; + textUnderlinePosition: string; + top: string; + touchAction: string; + transform: string; + transformOrigin: string; + transformStyle: string; + transition: string; + transitionDelay: string; + transitionDuration: string; + transitionProperty: string; + transitionTimingFunction: string; + turn: string; + unicodeBidi: string; + unicodeRange: string; + userSelect: string; + verticalAlign: string; + visibility: string; + webkitOverflowScrolling: string; + webkitTransform: string; + webkitTransformOrigin: string; + webkitTransitionDelay: string; + webkitTransitionDuration: string; + webkitTransitionProperty: string; + webkitTransitionTimingFunction: string; + whiteSpace: string; + widows: string; + width: string; + willChange: string; + wordBreak: string; + wordSpacing: string; + wordWrap: string; + writingMode: string; + zIndex: string; + + cssFloat: string; + cssText: string; + getPropertyPriority(property: string): string; + getPropertyValue(property: string): string; + item(index: number): string; + [index: number]: string; + length: number; + parentRule: CSSRule; + removeProperty(property: string): string; + setProperty(property: string, value: ?string, priority: ?string): void; + setPropertyPriority(property: string, priority: string): void; +} diff --git a/flow-typed/environments/dom.js b/flow-typed/environments/dom.js new file mode 100644 index 0000000000000..8e3e757073148 --- /dev/null +++ b/flow-typed/environments/dom.js @@ -0,0 +1,3676 @@ +// flow-typed signature: 2872ddd56ba4b4bfefacac38ebdc6087 +// flow-typed version: 3e51657e95/dom/flow_>=v0.261.x + +/* Files */ + +declare class Blob { + constructor( + blobParts?: Array, + options?: { + type?: string, + endings?: string, + ... + } + ): void; + isClosed: boolean; + size: number; + type: string; + close(): void; + slice(start?: number, end?: number, contentType?: string): Blob; + arrayBuffer(): Promise; + text(): Promise; + stream(): ReadableStream; +} + +declare class FileReader extends EventTarget { + +EMPTY: 0; + +LOADING: 1; + +DONE: 2; + +error: null | DOMError; + +readyState: 0 | 1 | 2; + +result: null | string | ArrayBuffer; + abort(): void; + onabort: null | ((ev: ProgressEvent) => any); + onerror: null | ((ev: ProgressEvent) => any); + onload: null | ((ev: ProgressEvent) => any); + onloadend: null | ((ev: ProgressEvent) => any); + onloadstart: null | ((ev: ProgressEvent) => any); + onprogress: null | ((ev: ProgressEvent) => any); + readAsArrayBuffer(blob: Blob): void; + readAsBinaryString(blob: Blob): void; + readAsDataURL(blob: Blob): void; + readAsText(blob: Blob, encoding?: string): void; +} + +declare type FilePropertyBag = { + type?: string, + lastModified?: number, + ... +}; +declare class File extends Blob { + constructor( + fileBits: $ReadOnlyArray, + filename: string, + options?: FilePropertyBag + ): void; + lastModified: number; + name: string; +} + +declare class FileList { + @@iterator(): Iterator; + length: number; + item(index: number): File; + [index: number]: File; +} + +declare class DOMError { + name: string; +} + +declare interface ShadowRoot extends DocumentFragment { + +delegatesFocus: boolean; + +host: Element; + // flowlint unsafe-getters-setters:off + get innerHTML(): string; + set innerHTML(value: string | TrustedHTML): void; + // flowlint unsafe-getters-setters:error + +mode: ShadowRootMode; + + // From DocumentOrShadowRoot Mixin. + +styleSheets: StyleSheetList; + adoptedStyleSheets: Array; +} + +declare type ShadowRootMode = 'open' | 'closed'; + +declare type ShadowRootInit = { + delegatesFocus?: boolean, + mode: ShadowRootMode, + ... +}; + +declare type ScrollToOptions = { + top?: number, + left?: number, + behavior?: 'auto' | 'smooth', + ... +}; + +type EventHandler = (event: Event) => mixed; +type EventListener = {handleEvent: EventHandler, ...} | EventHandler; +type MouseEventHandler = (event: MouseEvent) => mixed; +type MouseEventListener = + | {handleEvent: MouseEventHandler, ...} + | MouseEventHandler; +type FocusEventHandler = (event: FocusEvent) => mixed; +type FocusEventListener = + | {handleEvent: FocusEventHandler, ...} + | FocusEventHandler; +type KeyboardEventHandler = (event: KeyboardEvent) => mixed; +type KeyboardEventListener = + | {handleEvent: KeyboardEventHandler, ...} + | KeyboardEventHandler; +type InputEventHandler = (event: InputEvent) => mixed; +type InputEventListener = + | {handleEvent: InputEventHandler, ...} + | InputEventHandler; +type TouchEventHandler = (event: TouchEvent) => mixed; +type TouchEventListener = + | {handleEvent: TouchEventHandler, ...} + | TouchEventHandler; +type WheelEventHandler = (event: WheelEvent) => mixed; +type WheelEventListener = + | {handleEvent: WheelEventHandler, ...} + | WheelEventHandler; +type AbortProgressEventHandler = (event: ProgressEvent) => mixed; +type AbortProgressEventListener = + | {handleEvent: AbortProgressEventHandler, ...} + | AbortProgressEventHandler; +type ProgressEventHandler = (event: ProgressEvent) => mixed; +type ProgressEventListener = + | {handleEvent: ProgressEventHandler, ...} + | ProgressEventHandler; +type DragEventHandler = (event: DragEvent) => mixed; +type DragEventListener = + | {handleEvent: DragEventHandler, ...} + | DragEventHandler; +type PointerEventHandler = (event: PointerEvent) => mixed; +type PointerEventListener = + | {handleEvent: PointerEventHandler, ...} + | PointerEventHandler; +type AnimationEventHandler = (event: AnimationEvent) => mixed; +type AnimationEventListener = + | {handleEvent: AnimationEventHandler, ...} + | AnimationEventHandler; +type ClipboardEventHandler = (event: ClipboardEvent) => mixed; +type ClipboardEventListener = + | {handleEvent: ClipboardEventHandler, ...} + | ClipboardEventHandler; +type TransitionEventHandler = (event: TransitionEvent) => mixed; +type TransitionEventListener = + | {handleEvent: TransitionEventHandler, ...} + | TransitionEventHandler; +type MessageEventHandler = (event: MessageEvent) => mixed; +type MessageEventListener = + | {handleEvent: MessageEventHandler, ...} + | MessageEventHandler; +type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => mixed; +type BeforeUnloadEventListener = + | {handleEvent: BeforeUnloadEventHandler, ...} + | BeforeUnloadEventHandler; +type StorageEventHandler = (event: StorageEvent) => mixed; +type StorageEventListener = + | {handleEvent: StorageEventHandler, ...} + | StorageEventHandler; +type SecurityPolicyViolationEventHandler = ( + event: SecurityPolicyViolationEvent +) => mixed; +type SecurityPolicyViolationEventListener = + | {handleEvent: SecurityPolicyViolationEventHandler, ...} + | SecurityPolicyViolationEventHandler; +type USBConnectionEventHandler = (event: USBConnectionEvent) => mixed; +type USBConnectionEventListener = + | {handleEvent: USBConnectionEventHandler, ...} + | USBConnectionEventHandler; + +type MediaKeySessionType = 'temporary' | 'persistent-license'; +type MediaKeyStatus = + | 'usable' + | 'expired' + | 'released' + | 'output-restricted' + | 'output-downscaled' + | 'status-pending' + | 'internal-error'; +type MouseEventTypes = + | 'contextmenu' + | 'mousedown' + | 'mouseenter' + | 'mouseleave' + | 'mousemove' + | 'mouseout' + | 'mouseover' + | 'mouseup' + | 'click' + | 'dblclick'; +type FocusEventTypes = 'blur' | 'focus' | 'focusin' | 'focusout'; +type KeyboardEventTypes = 'keydown' | 'keyup' | 'keypress'; +type InputEventTypes = 'input' | 'beforeinput'; +type TouchEventTypes = 'touchstart' | 'touchmove' | 'touchend' | 'touchcancel'; +type WheelEventTypes = 'wheel'; +type AbortProgressEventTypes = 'abort'; +type ProgressEventTypes = + | 'abort' + | 'error' + | 'load' + | 'loadend' + | 'loadstart' + | 'progress' + | 'timeout'; +type DragEventTypes = + | 'drag' + | 'dragend' + | 'dragenter' + | 'dragexit' + | 'dragleave' + | 'dragover' + | 'dragstart' + | 'drop'; +type PointerEventTypes = + | 'pointerover' + | 'pointerenter' + | 'pointerdown' + | 'pointermove' + | 'pointerup' + | 'pointercancel' + | 'pointerout' + | 'pointerleave' + | 'gotpointercapture' + | 'lostpointercapture'; +type AnimationEventTypes = + | 'animationstart' + | 'animationend' + | 'animationiteration'; +type ClipboardEventTypes = 'clipboardchange' | 'cut' | 'copy' | 'paste'; +type TransitionEventTypes = + | 'transitionrun' + | 'transitionstart' + | 'transitionend' + | 'transitioncancel'; +type MessageEventTypes = string; +type BeforeUnloadEventTypes = 'beforeunload'; +type StorageEventTypes = 'storage'; +type SecurityPolicyViolationEventTypes = 'securitypolicyviolation'; +type USBConnectionEventTypes = 'connect' | 'disconnect'; +type ToggleEventTypes = 'beforetoggle' | 'toggle'; +type EventListenerOptionsOrUseCapture = + | boolean + | { + capture?: boolean, + once?: boolean, + passive?: boolean, + signal?: AbortSignal, + ... + }; + +declare class EventTarget { + addEventListener( + type: MouseEventTypes, + listener: MouseEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: FocusEventTypes, + listener: FocusEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: KeyboardEventTypes, + listener: KeyboardEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: InputEventTypes, + listener: InputEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: TouchEventTypes, + listener: TouchEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: WheelEventTypes, + listener: WheelEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: AbortProgressEventTypes, + listener: AbortProgressEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: ProgressEventTypes, + listener: ProgressEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: DragEventTypes, + listener: DragEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: PointerEventTypes, + listener: PointerEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: AnimationEventTypes, + listener: AnimationEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: ClipboardEventTypes, + listener: ClipboardEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: TransitionEventTypes, + listener: TransitionEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: MessageEventTypes, + listener: MessageEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: BeforeUnloadEventTypes, + listener: BeforeUnloadEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: StorageEventTypes, + listener: StorageEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: SecurityPolicyViolationEventTypes, + listener: SecurityPolicyViolationEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: USBConnectionEventTypes, + listener: USBConnectionEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + addEventListener( + type: string, + listener: EventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + + removeEventListener( + type: MouseEventTypes, + listener: MouseEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: FocusEventTypes, + listener: FocusEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: KeyboardEventTypes, + listener: KeyboardEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: InputEventTypes, + listener: InputEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: TouchEventTypes, + listener: TouchEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: WheelEventTypes, + listener: WheelEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: AbortProgressEventTypes, + listener: AbortProgressEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: ProgressEventTypes, + listener: ProgressEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: DragEventTypes, + listener: DragEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: PointerEventTypes, + listener: PointerEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: AnimationEventTypes, + listener: AnimationEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: ClipboardEventTypes, + listener: ClipboardEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: TransitionEventTypes, + listener: TransitionEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: MessageEventTypes, + listener: MessageEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: BeforeUnloadEventTypes, + listener: BeforeUnloadEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: StorageEventTypes, + listener: StorageEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: SecurityPolicyViolationEventTypes, + listener: SecurityPolicyViolationEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: USBConnectionEventTypes, + listener: USBConnectionEventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + removeEventListener( + type: string, + listener: EventListener, + optionsOrUseCapture?: EventListenerOptionsOrUseCapture + ): void; + + attachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void; + attachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void; + attachEvent?: ( + type: KeyboardEventTypes, + listener: KeyboardEventListener + ) => void; + attachEvent?: (type: InputEventTypes, listener: InputEventListener) => void; + attachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void; + attachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void; + attachEvent?: ( + type: AbortProgressEventTypes, + listener: AbortProgressEventListener + ) => void; + attachEvent?: ( + type: ProgressEventTypes, + listener: ProgressEventListener + ) => void; + attachEvent?: (type: DragEventTypes, listener: DragEventListener) => void; + attachEvent?: ( + type: PointerEventTypes, + listener: PointerEventListener + ) => void; + attachEvent?: ( + type: AnimationEventTypes, + listener: AnimationEventListener + ) => void; + attachEvent?: ( + type: ClipboardEventTypes, + listener: ClipboardEventListener + ) => void; + attachEvent?: ( + type: TransitionEventTypes, + listener: TransitionEventListener + ) => void; + attachEvent?: ( + type: MessageEventTypes, + listener: MessageEventListener + ) => void; + attachEvent?: ( + type: BeforeUnloadEventTypes, + listener: BeforeUnloadEventListener + ) => void; + attachEvent?: ( + type: StorageEventTypes, + listener: StorageEventListener + ) => void; + attachEvent?: ( + type: USBConnectionEventTypes, + listener: USBConnectionEventListener + ) => void; + attachEvent?: (type: string, listener: EventListener) => void; + + detachEvent?: (type: MouseEventTypes, listener: MouseEventListener) => void; + detachEvent?: (type: FocusEventTypes, listener: FocusEventListener) => void; + detachEvent?: ( + type: KeyboardEventTypes, + listener: KeyboardEventListener + ) => void; + detachEvent?: (type: InputEventTypes, listener: InputEventListener) => void; + detachEvent?: (type: TouchEventTypes, listener: TouchEventListener) => void; + detachEvent?: (type: WheelEventTypes, listener: WheelEventListener) => void; + detachEvent?: ( + type: AbortProgressEventTypes, + listener: AbortProgressEventListener + ) => void; + detachEvent?: ( + type: ProgressEventTypes, + listener: ProgressEventListener + ) => void; + detachEvent?: (type: DragEventTypes, listener: DragEventListener) => void; + detachEvent?: ( + type: PointerEventTypes, + listener: PointerEventListener + ) => void; + detachEvent?: ( + type: AnimationEventTypes, + listener: AnimationEventListener + ) => void; + detachEvent?: ( + type: ClipboardEventTypes, + listener: ClipboardEventListener + ) => void; + detachEvent?: ( + type: TransitionEventTypes, + listener: TransitionEventListener + ) => void; + detachEvent?: ( + type: MessageEventTypes, + listener: MessageEventListener + ) => void; + detachEvent?: ( + type: BeforeUnloadEventTypes, + listener: BeforeUnloadEventListener + ) => void; + detachEvent?: ( + type: StorageEventTypes, + listener: StorageEventListener + ) => void; + detachEvent?: ( + type: USBConnectionEventTypes, + listener: USBConnectionEventListener + ) => void; + detachEvent?: (type: string, listener: EventListener) => void; + + dispatchEvent(evt: Event): boolean; + + // Deprecated + + cancelBubble: boolean; + initEvent( + eventTypeArg: string, + canBubbleArg: boolean, + cancelableArg: boolean + ): void; +} + +// https://dom.spec.whatwg.org/#dictdef-eventinit +type Event$Init = { + bubbles?: boolean, + cancelable?: boolean, + composed?: boolean, + /** Non-standard. See `composed` instead. */ + scoped?: boolean, + ... +}; + +// https://dom.spec.whatwg.org/#interface-event +declare class Event { + constructor(type: string, eventInitDict?: Event$Init): void; + /** + * Returns the type of event, e.g. "click", "hashchange", or "submit". + */ + +type: string; + /** + * Returns the object to which event is dispatched (its target). + */ + +target: EventTarget; // TODO: nullable + /** @deprecated */ + +srcElement: Element; // TODO: nullable + /** + * Returns the object whose event listener's callback is currently being invoked. + */ + +currentTarget: EventTarget; // TODO: nullable + /** + * Returns the invocation target objects of event's path (objects on which + * listeners will be invoked), except for any nodes in shadow trees of which + * the shadow root's mode is "closed" that are not reachable from event's + * currentTarget. + */ + composedPath(): Array; + + +NONE: number; + +AT_TARGET: number; + +BUBBLING_PHASE: number; + +CAPTURING_PHASE: number; + /** + * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, + * and BUBBLING_PHASE. + */ + +eventPhase: number; + + /** + * When dispatched in a tree, invoking this method prevents event from reaching + * any objects other than the current object. + */ + stopPropagation(): void; + /** + * Invoking this method prevents event from reaching any registered event + * listeners after the current one finishes running and, when dispatched in a + * tree, also prevents event from reaching any other objects. + */ + stopImmediatePropagation(): void; + + /** + * Returns true or false depending on how event was initialized. True if + * event goes through its target's ancestors in reverse tree order, and + * false otherwise. + */ + +bubbles: boolean; + /** + * Returns true or false depending on how event was initialized. Its + * return value does not always carry meaning, but true can indicate + * that part of the operation during which event was dispatched, can + * be canceled by invoking the preventDefault() method. + */ + +cancelable: boolean; + // returnValue: boolean; // legacy, and some subclasses still define it as a string! + /** + * If invoked when the cancelable attribute value is true, and while + * executing a listener for the event with passive set to false, signals to + * the operation that caused event to be dispatched that it needs to be + * canceled. + */ + preventDefault(): void; + /** + * Returns true if preventDefault() was invoked successfully to indicate + * cancelation, and false otherwise. + */ + +defaultPrevented: boolean; + /** + * Returns true or false depending on how event was initialized. True if + * event invokes listeners past a ShadowRoot node that is the root of its + * target, and false otherwise. + */ + +composed: boolean; + + /** + * Returns true if event was dispatched by the user agent, and false otherwise. + */ + +isTrusted: boolean; + /** + * Returns the event's timestamp as the number of milliseconds measured relative + * to the time origin. + */ + +timeStamp: number; + + /** Non-standard. See Event.prototype.composedPath */ + +deepPath?: () => EventTarget[]; + /** Non-standard. See Event.prototype.composed */ + +scoped: boolean; + + /** + * @deprecated + */ + initEvent(type: string, bubbles: boolean, cancelable: boolean): void; +} + +type CustomEvent$Init = {...Event$Init, detail?: any, ...}; + +declare class CustomEvent extends Event { + constructor(type: string, eventInitDict?: CustomEvent$Init): void; + detail: any; + + // deprecated + initCustomEvent( + type: string, + bubbles: boolean, + cancelable: boolean, + detail: any + ): CustomEvent; +} + +type UIEvent$Init = {...Event$Init, detail?: number, view?: any, ...}; + +declare class UIEvent extends Event { + constructor(typeArg: string, uiEventInit?: UIEvent$Init): void; + detail: number; + view: any; +} + +declare class CompositionEvent extends UIEvent { + data: string | null; + locale: string; +} + +type MouseEvent$MouseEventInit = { + screenX?: number, + screenY?: number, + clientX?: number, + clientY?: number, + ctrlKey?: boolean, + shiftKey?: boolean, + altKey?: boolean, + metaKey?: boolean, + button?: number, + buttons?: number, + region?: string | null, + relatedTarget?: EventTarget | null, + ... +}; + +declare class MouseEvent extends UIEvent { + constructor( + typeArg: string, + mouseEventInit?: MouseEvent$MouseEventInit + ): void; + altKey: boolean; + button: number; + buttons: number; + clientX: number; + clientY: number; + ctrlKey: boolean; + metaKey: boolean; + movementX: number; + movementY: number; + offsetX: number; + offsetY: number; + pageX: number; + pageY: number; + region: string | null; + relatedTarget: EventTarget | null; + screenX: number; + screenY: number; + shiftKey: boolean; + x: number; + y: number; + getModifierState(keyArg: string): boolean; +} + +declare class FocusEvent extends UIEvent { + relatedTarget: ?EventTarget; +} + +type WheelEvent$Init = { + ...MouseEvent$MouseEventInit, + deltaX?: number, + deltaY?: number, + deltaZ?: number, + deltaMode?: 0x00 | 0x01 | 0x02, + ... +}; + +declare class WheelEvent extends MouseEvent { + static +DOM_DELTA_PIXEL: 0x00; + static +DOM_DELTA_LINE: 0x01; + static +DOM_DELTA_PAGE: 0x02; + + constructor(type: string, eventInitDict?: WheelEvent$Init): void; + +deltaX: number; + +deltaY: number; + +deltaZ: number; + +deltaMode: 0x00 | 0x01 | 0x02; +} + +declare class DragEvent extends MouseEvent { + dataTransfer: ?DataTransfer; // readonly +} + +type PointerEvent$PointerEventInit = MouseEvent$MouseEventInit & { + pointerId?: number, + width?: number, + height?: number, + pressure?: number, + tangentialPressure?: number, + tiltX?: number, + tiltY?: number, + twist?: number, + pointerType?: string, + isPrimary?: boolean, + ... +}; + +declare class PointerEvent extends MouseEvent { + constructor( + typeArg: string, + pointerEventInit?: PointerEvent$PointerEventInit + ): void; + pointerId: number; + width: number; + height: number; + pressure: number; + tangentialPressure: number; + tiltX: number; + tiltY: number; + twist: number; + pointerType: string; + isPrimary: boolean; +} + +declare class ProgressEvent extends Event { + lengthComputable: boolean; + loaded: number; + total: number; + + // Deprecated + initProgressEvent( + typeArg: string, + canBubbleArg: boolean, + cancelableArg: boolean, + lengthComputableArg: boolean, + loadedArg: number, + totalArg: number + ): void; +} + +declare class PromiseRejectionEvent extends Event { + promise: Promise; + reason: any; +} + +type PageTransitionEventInit = { + ...Event$Init, + persisted: boolean, + ... +}; + +// https://html.spec.whatwg.org/multipage/browsing-the-web.html#the-pagetransitionevent-interface +declare class PageTransitionEvent extends Event { + constructor(type: string, init?: PageTransitionEventInit): void; + +persisted: boolean; +} + +// used for websockets and postMessage, for example. See: +// https://www.w3.org/TR/2011/WD-websockets-20110419/ +// and +// https://www.w3.org/TR/2008/WD-html5-20080610/comms.html +// and +// https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interfaces +declare class MessageEvent extends Event { + data: mixed; + origin: string; + lastEventId: string; + source: WindowProxy; +} + +// https://w3c.github.io/uievents/#idl-keyboardeventinit +type KeyboardEvent$Init = { + ...UIEvent$Init, + /** + * Initializes the `key` attribute of the KeyboardEvent object to the unicode + * character string representing the meaning of a key after taking into + * account all keyboard modifiers (such as shift-state). This value is the + * final effective value of the key. If the key is not a printable character, + * then it should be one of the key values defined in [UIEvents-Key](https://www.w3.org/TR/uievents-key/). + * + * NOTE: not `null`, this results in `evt.key === 'null'`! + */ + key?: string | void, + /** + * Initializes the `code` attribute of the KeyboardEvent object to the unicode + * character string representing the key that was pressed, ignoring any + * keyboard modifications such as keyboard layout. This value should be one + * of the code values defined in [UIEvents-Code](https://www.w3.org/TR/uievents-code/). + * + * NOTE: not `null`, this results in `evt.code === 'null'`! + */ + code?: string | void, + /** + * Initializes the `location` attribute of the KeyboardEvent object to one of + * the following location numerical constants: + * + * DOM_KEY_LOCATION_STANDARD (numerical value 0) + * DOM_KEY_LOCATION_LEFT (numerical value 1) + * DOM_KEY_LOCATION_RIGHT (numerical value 2) + * DOM_KEY_LOCATION_NUMPAD (numerical value 3) + */ + location?: number, + /** + * Initializes the `ctrlKey` attribute of the KeyboardEvent object to true if + * the Control key modifier is to be considered active, false otherwise. + */ + ctrlKey?: boolean, + /** + * Initializes the `shiftKey` attribute of the KeyboardEvent object to true if + * the Shift key modifier is to be considered active, false otherwise. + */ + shiftKey?: boolean, + /** + * Initializes the `altKey` attribute of the KeyboardEvent object to true if + * the Alt (alternative) (or Option) key modifier is to be considered active, + * false otherwise. + */ + altKey?: boolean, + /** + * Initializes the `metaKey` attribute of the KeyboardEvent object to true if + * the Meta key modifier is to be considered active, false otherwise. + */ + metaKey?: boolean, + /** + * Initializes the `repeat` attribute of the KeyboardEvent object. This + * attribute should be set to true if the the current KeyboardEvent is + * considered part of a repeating sequence of similar events caused by the + * long depression of any single key, false otherwise. + */ + repeat?: boolean, + /** + * Initializes the `isComposing` attribute of the KeyboardEvent object. This + * attribute should be set to true if the event being constructed occurs as + * part of a composition sequence, false otherwise. + */ + isComposing?: boolean, + /** + * Initializes the `charCode` attribute of the KeyboardEvent to the Unicode + * code point for the event’s character. + */ + charCode?: number, + /** + * Initializes the `keyCode` attribute of the KeyboardEvent to the system- + * and implementation-dependent numerical code signifying the unmodified + * identifier associated with the key pressed. + */ + keyCode?: number, + /** Initializes the `which` attribute */ + which?: number, + ... +}; + +// https://w3c.github.io/uievents/#idl-keyboardevent +declare class KeyboardEvent extends UIEvent { + constructor(typeArg: string, init?: KeyboardEvent$Init): void; + + /** `true` if the Alt (alternative) (or "Option") key modifier was active. */ + +altKey: boolean; + /** + * Holds a string that identifies the physical key being pressed. The value + * is not affected by the current keyboard layout or modifier state, so a + * particular key will always return the same value. + */ + +code: string; + /** `true` if the Control (control) key modifier was active. */ + +ctrlKey: boolean; + /** + * `true` if the key event occurs as part of a composition session, i.e., + * after a `compositionstart` event and before the corresponding + * `compositionend` event. + */ + +isComposing: boolean; + /** + * Holds a [key attribute value](https://www.w3.org/TR/uievents-key/#key-attribute-value) + * corresponding to the key pressed. */ + +key: string; + /** An indication of the logical location of the key on the device. */ + +location: number; + /** `true` if the meta (Meta) key (or "Command") modifier was active. */ + +metaKey: boolean; + /** `true` if the key has been pressed in a sustained manner. */ + +repeat: boolean; + /** `true` if the shift (Shift) key modifier was active. */ + +shiftKey: boolean; + + /** + * Queries the state of a modifier using a key value. + * + * Returns `true` if it is a modifier key and the modifier is activated, + * `false` otherwise. + */ + getModifierState(keyArg?: string): boolean; + + /** + * Holds a character value, for keypress events which generate character + * input. The value is the Unicode reference number (code point) of that + * character (e.g. event.charCode = event.key.charCodeAt(0) for printable + * characters). For keydown or keyup events, the value of charCode is 0. + * + * @deprecated You should use KeyboardEvent.key instead, if available. + */ + +charCode: number; + /** + * Holds a system- and implementation-dependent numerical code signifying + * the unmodified identifier associated with the key pressed. Unlike the + * `key` attribute, the set of possible values are not normatively defined. + * Typically, these value of the keyCode SHOULD represent the decimal + * codepoint in ASCII or Windows 1252, but MAY be drawn from a different + * appropriate character set. Implementations that are unable to identify + * a key use the key value 0. + * + * @deprecated You should use KeyboardEvent.key instead, if available. + */ + +keyCode: number; + /** + * Holds a system- and implementation-dependent numerical code signifying + * the unmodified identifier associated with the key pressed. In most cases, + * the value is identical to keyCode. + * + * @deprecated You should use KeyboardEvent.key instead, if available. + */ + +which: number; +} + +type InputEvent$Init = { + ...UIEvent$Init, + inputType?: string, + data?: string, + dataTransfer?: DataTransfer, + isComposing?: boolean, + ranges?: Array, // TODO: StaticRange + ... +}; + +declare class InputEvent extends UIEvent { + constructor(typeArg: string, inputEventInit: InputEvent$Init): void; + +data: string | null; + +dataTransfer: DataTransfer | null; + +inputType: string; + +isComposing: boolean; + getTargetRanges(): Array; // TODO: StaticRange +} + +declare class AnimationEvent extends Event { + animationName: string; + elapsedTime: number; + pseudoElement: string; + + // deprecated + + initAnimationEvent: ( + type: 'animationstart' | 'animationend' | 'animationiteration', + canBubble: boolean, + cancelable: boolean, + animationName: string, + elapsedTime: number + ) => void; +} + +// https://www.w3.org/TR/touch-events/#idl-def-Touch +declare class Touch { + clientX: number; + clientY: number; + identifier: number; + pageX: number; + pageY: number; + screenX: number; + screenY: number; + target: EventTarget; +} + +// https://www.w3.org/TR/touch-events/#idl-def-TouchList +// TouchList#item(index) will return null if n > #length. Should #item's +// return type just been Touch? +declare class TouchList { + @@iterator(): Iterator; + length: number; + item(index: number): null | Touch; + [index: number]: Touch; +} + +// https://www.w3.org/TR/touch-events/#touchevent-interface +declare class TouchEvent extends UIEvent { + altKey: boolean; + changedTouches: TouchList; + ctrlKey: boolean; + metaKey: boolean; + shiftKey: boolean; + targetTouches: TouchList; + touches: TouchList; +} + +// https://www.w3.org/TR/clipboard-apis/#typedefdef-clipboarditemdata +// Raw string | Blob are allowed per https://webidl.spec.whatwg.org/#es-promise +type ClipboardItemData = string | Blob | Promise; + +type PresentationStyle = 'attachment' | 'inline' | 'unspecified'; + +type ClipboardItemOptions = { + presentationStyle?: PresentationStyle, + ... +}; + +declare class ClipboardItem { + +types: $ReadOnlyArray; + getType(type: string): Promise; + constructor( + items: {[type: string]: ClipboardItemData}, + options?: ClipboardItemOptions + ): void; +} + +// https://w3c.github.io/clipboard-apis/ as of 15 May 2018 +type ClipboardEvent$Init = { + ...Event$Init, + clipboardData: DataTransfer | null, + ... +}; + +declare class ClipboardEvent extends Event { + constructor(type: ClipboardEventTypes, eventInit?: ClipboardEvent$Init): void; + +clipboardData: ?DataTransfer; // readonly +} + +// https://www.w3.org/TR/2017/WD-css-transitions-1-20171130/#interface-transitionevent +type TransitionEvent$Init = { + ...Event$Init, + propertyName: string, + elapsedTime: number, + pseudoElement: string, + ... +}; + +declare class TransitionEvent extends Event { + constructor( + type: TransitionEventTypes, + eventInit?: TransitionEvent$Init + ): void; + + +propertyName: string; // readonly + +elapsedTime: number; // readonly + +pseudoElement: string; // readonly +} + +declare class SecurityPolicyViolationEvent extends Event { + +documentURI: string; + +referrer: string; + +blockedURI: string; + +effectiveDirective: string; + +violatedDirective: string; + +originalPolicy: string; + +sourceFile: string; + +sample: string; + +disposition: 'enforce' | 'report'; + +statusCode: number; + +lineNumber: number; + +columnNumber: number; +} + +// https://developer.mozilla.org/en-US/docs/Web/API/USBConnectionEvent +declare class USBConnectionEvent extends Event { + device: USBDevice; +} + +// TODO: *Event + +declare class AbortController { + constructor(): void; + +signal: AbortSignal; + abort(reason?: any): void; +} + +declare class AbortSignal extends EventTarget { + +aborted: boolean; + +reason: any; + abort(reason?: any): AbortSignal; + onabort: (event: Event) => mixed; + throwIfAborted(): void; + timeout(time: number): AbortSignal; +} + +declare class Node extends EventTarget { + baseURI: ?string; + childNodes: NodeList; + firstChild: ?Node; + +isConnected: boolean; + lastChild: ?Node; + nextSibling: ?Node; + nodeName: string; + nodeType: number; + nodeValue: string; + ownerDocument: Document; + parentElement: ?Element; + parentNode: ?Node; + previousSibling: ?Node; + rootNode: Node; + textContent: string; + appendChild(newChild: T): T; + cloneNode(deep?: boolean): this; + compareDocumentPosition(other: Node): number; + contains(other: ?Node): boolean; + getRootNode(options?: {composed: boolean, ...}): Node; + hasChildNodes(): boolean; + insertBefore(newChild: T, refChild?: ?Node): T; + isDefaultNamespace(namespaceURI: string): boolean; + isEqualNode(arg: Node): boolean; + isSameNode(other: Node): boolean; + lookupNamespaceURI(prefix: string): string; + lookupPrefix(namespaceURI: string): string; + normalize(): void; + removeChild(oldChild: T): T; + replaceChild(newChild: Node, oldChild: T): T; + replaceChildren(...nodes: $ReadOnlyArray): void; + static ATTRIBUTE_NODE: number; + static CDATA_SECTION_NODE: number; + static COMMENT_NODE: number; + static DOCUMENT_FRAGMENT_NODE: number; + static DOCUMENT_NODE: number; + static DOCUMENT_POSITION_CONTAINED_BY: number; + static DOCUMENT_POSITION_CONTAINS: number; + static DOCUMENT_POSITION_DISCONNECTED: number; + static DOCUMENT_POSITION_FOLLOWING: number; + static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number; + static DOCUMENT_POSITION_PRECEDING: number; + static DOCUMENT_TYPE_NODE: number; + static ELEMENT_NODE: number; + static ENTITY_NODE: number; + static ENTITY_REFERENCE_NODE: number; + static NOTATION_NODE: number; + static PROCESSING_INSTRUCTION_NODE: number; + static TEXT_NODE: number; + + // Non-standard + innerText?: string; + outerText?: string; +} + +declare class NodeList { + @@iterator(): Iterator; + length: number; + item(index: number): T; + [index: number]: T; + + forEach( + callbackfn: (this: This, value: T, index: number, list: NodeList) => any, + thisArg: This + ): void; + entries(): Iterator<[number, T]>; + keys(): Iterator; + values(): Iterator; +} + +declare class NamedNodeMap { + @@iterator(): Iterator; + length: number; + removeNamedItemNS(namespaceURI: string, localName: string): Attr; + item(index: number): Attr; + [index: number | string]: Attr; + removeNamedItem(name: string): Attr; + getNamedItem(name: string): Attr; + setNamedItem(arg: Attr): Attr; + getNamedItemNS(namespaceURI: string, localName: string): Attr; + setNamedItemNS(arg: Attr): Attr; +} + +declare class Attr extends Node { + isId: boolean; + specified: boolean; + ownerElement: Element | null; + value: string; + name: string; + namespaceURI: string | null; + prefix: string | null; + localName: string; +} + +declare class HTMLCollection<+Elem: Element> { + @@iterator(): Iterator; + length: number; + item(nameOrIndex?: any, optionalIndex?: any): Elem | null; + namedItem(name: string): Elem | null; + [index: number | string]: Elem; +} + +// from https://www.w3.org/TR/custom-elements/#extensions-to-document-interface-to-register +// See also https://github.com/w3c/webcomponents/ +type ElementRegistrationOptions = { + +prototype?: { + // from https://www.w3.org/TR/custom-elements/#types-of-callbacks + // See also https://github.com/w3c/webcomponents/ + +createdCallback?: () => mixed, + +attachedCallback?: () => mixed, + +detachedCallback?: () => mixed, + +attributeChangedCallback?: (( + // attribute is set + attributeLocalName: string, + oldAttributeValue: null, + newAttributeValue: string, + attributeNamespace: string + ) => mixed) & + // attribute is changed + (( + attributeLocalName: string, + oldAttributeValue: string, + newAttributeValue: string, + attributeNamespace: string + ) => mixed) & + // attribute is removed + (( + attributeLocalName: string, + oldAttributeValue: string, + newAttributeValue: null, + attributeNamespace: string + ) => mixed), + ... + }, + +extends?: string, + ... +}; + +type ElementCreationOptions = {is: string, ...}; + +declare class MutationRecord { + type: 'attributes' | 'characterData' | 'childList'; + target: Node; + addedNodes: NodeList; + removedNodes: NodeList; + previousSibling: ?Node; + nextSibling: ?Node; + attributeName: ?string; + attributeNamespace: ?string; + oldValue: ?string; +} + +type MutationObserverInitRequired = + | {childList: true, ...} + | {attributes: true, ...} + | {characterData: true, ...}; + +declare type MutationObserverInit = MutationObserverInitRequired & { + subtree?: boolean, + attributeOldValue?: boolean, + characterDataOldValue?: boolean, + attributeFilter?: Array, + ... +}; + +declare class MutationObserver { + constructor( + callback: (arr: Array, observer: MutationObserver) => mixed + ): void; + observe(target: Node, options: MutationObserverInit): void; + takeRecords(): Array; + disconnect(): void; +} + +declare class Document extends Node { + +timeline: DocumentTimeline; + getAnimations(): Array; + +URL: string; + adoptNode(source: T): T; + anchors: HTMLCollection; + applets: HTMLCollection; + body: HTMLBodyElement | null; + +characterSet: string; + /** + * Legacy alias of `characterSet` + * @deprecated + */ + +charset: string; + close(): void; + +contentType: string; + cookie: string; + createAttribute(name: string): Attr; + createAttributeNS(namespaceURI: string | null, qualifiedName: string): Attr; + createCDATASection(data: string): Text; + createComment(data: string): Comment; + createDocumentFragment(): DocumentFragment; + createElement>( + localName: TName, + options?: string | ElementCreationOptions + ): HTMLElementTagNameMap[TName]; + createElementNS>( + namespaceURI: 'http://www.w3.org/1999/xhtml', + qualifiedName: TName, + options?: string | ElementCreationOptions + ): HTMLElementTagNameMap[TName]; + createElementNS( + namespaceURI: string | null, + qualifiedName: string, + options?: string | ElementCreationOptions + ): Element; + createTextNode(data: string): Text; + currentScript: HTMLScriptElement | null; + dir: 'rtl' | 'ltr'; + +doctype: DocumentType | null; + +documentElement: HTMLElement | null; + documentMode: number; + +documentURI: string; + domain: string | null; + embeds: HTMLCollection; + exitFullscreen(): Promise; + queryCommandSupported(cmdID: string): boolean; + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean; + forms: HTMLCollection; + fullscreenElement: Element | null; + fullscreenEnabled: boolean; + getElementsByClassName(classNames: string): HTMLCollection; + getElementsByName(elementName: string): HTMLCollection; + getElementsByTagName>( + qualifiedName: TName + ): HTMLCollection; + getElementsByTagNameNS>( + namespaceURI: 'http://www.w3.org/1999/xhtml', + qualifiedName: TName + ): HTMLCollection; + getElementsByTagNameNS( + namespaceURI: string | null, + qualifiedName: string + ): HTMLCollection; + head: HTMLHeadElement | null; + images: HTMLCollection; + +implementation: DOMImplementation; + importNode(importedNode: T, deep: boolean): T; + /** + * Legacy alias of `characterSet` + * @deprecated + */ + +inputEncoding: string; + lastModified: string; + links: HTMLCollection; + media: string; + open(url?: string, name?: string, features?: string, replace?: boolean): any; + readyState: string; + referrer: string; + scripts: HTMLCollection; + scrollingElement: HTMLElement | null; + title: string; + visibilityState: 'visible' | 'hidden' | 'prerender' | 'unloaded'; + write(...content: Array): void; + writeln(...content: Array): void; + xmlEncoding: string; + xmlStandalone: boolean; + xmlVersion: string; + + registerElement(type: string, options?: ElementRegistrationOptions): any; + getSelection(): Selection | null; + + // 6.4.6 Focus management APIs + activeElement: HTMLElement | null; + hasFocus(): boolean; + + // extension + location: Location; + createEvent(eventInterface: 'CustomEvent'): CustomEvent; + createEvent(eventInterface: string): Event; + createRange(): Range; + elementFromPoint(x: number, y: number): HTMLElement | null; + elementsFromPoint(x: number, y: number): Array; + defaultView: any; + +compatMode: 'BackCompat' | 'CSS1Compat'; + hidden: boolean; + + // Pointer Lock specification + exitPointerLock(): void; + pointerLockElement: Element | null; + + // from ParentNode interface + childElementCount: number; + children: HTMLCollection; + firstElementChild: ?Element; + lastElementChild: ?Element; + append(...nodes: Array): void; + prepend(...nodes: Array): void; + + querySelector>( + selector: TSelector + ): HTMLElementTagNameMap[TSelector] | null; + querySelectorAll>( + selector: TSelector + ): NodeList; + // Interface DocumentTraversal + // http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113/traversal.html#Traversal-Document + + // Not all combinations of RootNodeT and whatToShow are logically possible. + // The bitmasks NodeFilter.SHOW_CDATA_SECTION, + // NodeFilter.SHOW_ENTITY_REFERENCE, NodeFilter.SHOW_ENTITY, and + // NodeFilter.SHOW_NOTATION are deprecated and do not correspond to types + // that Flow knows about. + + // NodeFilter.SHOW_ATTRIBUTE is also deprecated, but corresponds to the + // type Attr. While there is no reason to prefer it to Node.attributes, + // it does have meaning and can be typed: When (whatToShow & + // NodeFilter.SHOW_ATTRIBUTE === 1), RootNodeT must be Attr, and when + // RootNodeT is Attr, bitmasks other than NodeFilter.SHOW_ATTRIBUTE are + // meaningless. + createNodeIterator( + root: RootNodeT, + whatToShow: 2, + filter?: NodeFilterInterface + ): NodeIterator; + createTreeWalker( + root: RootNodeT, + whatToShow: 2, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + + // NodeFilter.SHOW_PROCESSING_INSTRUCTION is not implemented because Flow + // does not currently define a ProcessingInstruction class. + + // When (whatToShow & NodeFilter.SHOW_DOCUMENT === 1 || whatToShow & + // NodeFilter.SHOW_DOCUMENT_TYPE === 1), RootNodeT must be Document. + createNodeIterator( + root: RootNodeT, + whatToShow: 256, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 257, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 260, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 261, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 384, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 385, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 388, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 389, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 512, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 513, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 516, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 517, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 640, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 641, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 644, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 645, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 768, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 769, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 772, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 773, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 896, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 897, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 900, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 901, + filter?: NodeFilterInterface + ): NodeIterator< + RootNodeT, + DocumentType | Document | Element | Text | Comment, + >; + createTreeWalker( + root: RootNodeT, + whatToShow: 256, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 257, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 260, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 261, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 384, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 385, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 388, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 389, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 512, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 513, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 516, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 517, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 640, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 641, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 644, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 645, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 768, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 769, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 772, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 773, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 896, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 897, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 900, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 901, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + + // When (whatToShow & NodeFilter.SHOW_DOCUMENT_FRAGMENT === 1), RootNodeT + // must be a DocumentFragment. + createNodeIterator( + root: RootNodeT, + whatToShow: 1024, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1025, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1028, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1029, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1152, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1153, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1156, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 1157, + filter?: NodeFilterInterface + ): NodeIterator; + createTreeWalker( + root: RootNodeT, + whatToShow: 1024, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1025, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1028, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1029, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1152, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1153, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1156, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 1157, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + + // In the general case, RootNodeT may be any Node and whatToShow may be + // NodeFilter.SHOW_ALL or any combination of NodeFilter.SHOW_ELEMENT, + // NodeFilter.SHOW_TEXT and/or NodeFilter.SHOW_COMMENT + createNodeIterator( + root: RootNodeT, + whatToShow: 1, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 4, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 5, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 128, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 129, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 132, + filter?: NodeFilterInterface + ): NodeIterator; + createNodeIterator( + root: RootNodeT, + whatToShow: 133, + filter?: NodeFilterInterface + ): NodeIterator; + createTreeWalker( + root: RootNodeT, + whatToShow: 1, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 4, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 5, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 128, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 129, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 132, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + createTreeWalker( + root: RootNodeT, + whatToShow: 133, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + + // Catch all for when we don't know the value of `whatToShow` + // And for when whatToShow is not provided, it is assumed to be SHOW_ALL + createNodeIterator( + root: RootNodeT, + whatToShow?: number, + filter?: NodeFilterInterface + ): NodeIterator; + createTreeWalker( + root: RootNodeT, + whatToShow?: number, + filter?: NodeFilterInterface, + entityReferenceExpansion?: boolean + ): TreeWalker; + + // From NonElementParentNode Mixin. + getElementById(elementId: string): HTMLElement | null; + + // From DocumentOrShadowRoot Mixin. + +styleSheets: StyleSheetList; + adoptedStyleSheets: Array; +} + +declare class DocumentFragment extends Node { + // from ParentNode interface + childElementCount: number; + children: HTMLCollection; + firstElementChild: ?Element; + lastElementChild: ?Element; + append(...nodes: Array): void; + prepend(...nodes: Array): void; + + querySelector(selector: string): HTMLElement | null; + querySelectorAll(selector: string): NodeList; + + // From NonElementParentNode Mixin. + getElementById(elementId: string): HTMLElement | null; +} + +declare class Selection { + anchorNode: Node | null; + anchorOffset: number; + focusNode: Node | null; + focusOffset: number; + isCollapsed: boolean; + rangeCount: number; + type: string; + addRange(range: Range): void; + getRangeAt(index: number): Range; + removeRange(range: Range): void; + removeAllRanges(): void; + collapse(parentNode: Node | null, offset?: number): void; + collapseToStart(): void; + collapseToEnd(): void; + containsNode(aNode: Node, aPartlyContained?: boolean): boolean; + deleteFromDocument(): void; + extend(parentNode: Node, offset?: number): void; + empty(): void; + selectAllChildren(parentNode: Node): void; + setPosition(aNode: Node | null, offset?: number): void; + setBaseAndExtent( + anchorNode: Node, + anchorOffset: number, + focusNode: Node, + focusOffset: number + ): void; + toString(): string; +} + +declare class Range { + // extension + startOffset: number; + collapsed: boolean; + endOffset: number; + startContainer: Node; + endContainer: Node; + commonAncestorContainer: Node; + setStart(refNode: Node, offset: number): void; + setEndBefore(refNode: Node): void; + setStartBefore(refNode: Node): void; + selectNode(refNode: Node): void; + detach(): void; + getBoundingClientRect(): DOMRect; + toString(): string; + compareBoundaryPoints(how: number, sourceRange: Range): number; + insertNode(newNode: Node): void; + collapse(toStart: boolean): void; + selectNodeContents(refNode: Node): void; + cloneContents(): DocumentFragment; + setEnd(refNode: Node, offset: number): void; + cloneRange(): Range; + getClientRects(): DOMRectList; + surroundContents(newParent: Node): void; + deleteContents(): void; + setStartAfter(refNode: Node): void; + extractContents(): DocumentFragment; + setEndAfter(refNode: Node): void; + createContextualFragment(fragment: string | TrustedHTML): DocumentFragment; + intersectsNode(refNode: Node): boolean; + isPointInRange(refNode: Node, offset: number): boolean; + static END_TO_END: number; + static START_TO_START: number; + static START_TO_END: number; + static END_TO_START: number; +} + +declare var document: Document; + +declare class DOMTokenList { + @@iterator(): Iterator; + length: number; + item(index: number): string; + contains(token: string): boolean; + add(...token: Array): void; + remove(...token: Array): void; + toggle(token: string, force?: boolean): boolean; + replace(oldToken: string, newToken: string): boolean; + + forEach( + callbackfn: (value: string, index: number, list: DOMTokenList) => any, + thisArg?: any + ): void; + entries(): Iterator<[number, string]>; + keys(): Iterator; + values(): Iterator; + [index: number]: string; +} + +declare class Element extends Node mixins mixin$Animatable { + assignedSlot: ?HTMLSlotElement; + attachShadow(shadowRootInitDict: ShadowRootInit): ShadowRoot; + attributes: NamedNodeMap; + classList: DOMTokenList; + className: string; + clientHeight: number; + clientLeft: number; + clientTop: number; + clientWidth: number; + id: string; + // flowlint unsafe-getters-setters:off + get innerHTML(): string; + set innerHTML(value: string | TrustedHTML): void; + // flowlint unsafe-getters-setters:error + localName: string; + namespaceURI: ?string; + nextElementSibling: ?Element; + // flowlint unsafe-getters-setters:off + get outerHTML(): string; + set outerHTML(value: string | TrustedHTML): void; + // flowlint unsafe-getters-setters:error + prefix: string | null; + previousElementSibling: ?Element; + scrollHeight: number; + scrollLeft: number; + scrollTop: number; + scrollWidth: number; + +tagName: string; + + // TODO: a lot more ARIA properties + ariaHidden: void | 'true' | 'false'; + + closest(selectors: string): ?Element; + + getAttribute(name?: string): ?string; + getAttributeNames(): Array; + getAttributeNS(namespaceURI: string | null, localName: string): string | null; + getAttributeNode(name: string): Attr | null; + getAttributeNodeNS( + namespaceURI: string | null, + localName: string + ): Attr | null; + getBoundingClientRect(): DOMRect; + getClientRects(): DOMRectList; + getElementsByClassName(names: string): HTMLCollection; + getElementsByTagName>( + qualifiedName: TName + ): HTMLCollection; + getElementsByTagNameNS>( + namespaceURI: 'http://www.w3.org/1999/xhtml', + qualifiedName: TName + ): HTMLCollection; + getElementsByTagNameNS( + namespaceURI: string | null, + qualifiedName: string + ): HTMLCollection; + + hasAttribute(name: string): boolean; + hasAttributeNS(namespaceURI: string | null, localName: string): boolean; + hasAttributes(): boolean; + hasPointerCapture(pointerId: number): boolean; + insertAdjacentElement( + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend', + element: Element + ): void; + insertAdjacentHTML( + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend', + html: string | TrustedHTML + ): void; + insertAdjacentText( + position: 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend', + text: string + ): void; + matches(selector: string): boolean; + releasePointerCapture(pointerId: number): void; + removeAttribute(name?: string): void; + removeAttributeNode(attributeNode: Attr): Attr; + removeAttributeNS(namespaceURI: string | null, localName: string): void; + requestFullscreen(options?: { + navigationUI: 'auto' | 'show' | 'hide', + ... + }): Promise; + requestPointerLock(): void; + scrollIntoView( + arg?: + | boolean + | { + behavior?: 'auto' | 'instant' | 'smooth', + block?: 'start' | 'center' | 'end' | 'nearest', + inline?: 'start' | 'center' | 'end' | 'nearest', + ... + } + ): void; + scroll(x: number, y: number): void; + scroll(options: ScrollToOptions): void; + scrollTo(x: number, y: number): void; + scrollTo(options: ScrollToOptions): void; + scrollBy(x: number, y: number): void; + scrollBy(options: ScrollToOptions): void; + setAttribute(name?: string, value?: string): void; + toggleAttribute(name?: string, force?: boolean): void; + setAttributeNS( + namespaceURI: string | null, + qualifiedName: string, + value: string + ): void; + setAttributeNode(newAttr: Attr): Attr | null; + setAttributeNodeNS(newAttr: Attr): Attr | null; + setPointerCapture(pointerId: number): void; + shadowRoot?: ShadowRoot; + slot?: string; + + // from ParentNode interface + childElementCount: number; + children: HTMLCollection; + firstElementChild: ?Element; + lastElementChild: ?Element; + append(...nodes: Array): void; + prepend(...nodes: Array): void; + + querySelector>( + selector: TSelector + ): HTMLElementTagNameMap[TSelector] | null; + querySelectorAll>( + selector: TSelector + ): NodeList; + + // from ChildNode interface + after(...nodes: Array): void; + before(...nodes: Array): void; + replaceWith(...nodes: Array): void; + remove(): void; +} + +declare class HitRegionOptions { + path?: Path2D; + fillRule?: CanvasFillRule; + id?: string; + parentID?: string; + cursor?: string; + control?: Element; + label: ?string; + role: ?string; +} + +declare class SVGMatrix { + getComponent(index: number): number; + mMultiply(secondMatrix: SVGMatrix): SVGMatrix; + inverse(): SVGMatrix; + mTranslate(x: number, y: number): SVGMatrix; + mScale(scaleFactor: number): SVGMatrix; + mRotate(angle: number): SVGMatrix; +} + +// WebGL idl: https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl + +type WebGLContextAttributes = { + alpha: boolean, + depth: boolean, + stencil: boolean, + antialias: boolean, + premultipliedAlpha: boolean, + preserveDrawingBuffer: boolean, + preferLowPowerToHighPerformance: boolean, + failIfMajorPerformanceCaveat: boolean, + ... +}; + +interface WebGLObject {} + +interface WebGLBuffer extends WebGLObject {} + +interface WebGLFramebuffer extends WebGLObject {} + +interface WebGLProgram extends WebGLObject {} + +interface WebGLRenderbuffer extends WebGLObject {} + +interface WebGLShader extends WebGLObject {} + +interface WebGLTexture extends WebGLObject {} + +interface WebGLUniformLocation {} + +interface WebGLActiveInfo { + size: number; + type: number; + name: string; +} + +interface WebGLShaderPrecisionFormat { + rangeMin: number; + rangeMax: number; + precision: number; +} + +type BufferDataSource = ArrayBuffer | $ArrayBufferView; + +type TexImageSource = + | ImageBitmap + | ImageData + | HTMLImageElement + | HTMLCanvasElement + | HTMLVideoElement; + +type VertexAttribFVSource = Float32Array | Array; + +/* flow */ +declare class WebGLRenderingContext { + static DEPTH_BUFFER_BIT: 0x00000100; + DEPTH_BUFFER_BIT: 0x00000100; + static STENCIL_BUFFER_BIT: 0x00000400; + STENCIL_BUFFER_BIT: 0x00000400; + static COLOR_BUFFER_BIT: 0x00004000; + COLOR_BUFFER_BIT: 0x00004000; + static POINTS: 0x0000; + POINTS: 0x0000; + static LINES: 0x0001; + LINES: 0x0001; + static LINE_LOOP: 0x0002; + LINE_LOOP: 0x0002; + static LINE_STRIP: 0x0003; + LINE_STRIP: 0x0003; + static TRIANGLES: 0x0004; + TRIANGLES: 0x0004; + static TRIANGLE_STRIP: 0x0005; + TRIANGLE_STRIP: 0x0005; + static TRIANGLE_FAN: 0x0006; + TRIANGLE_FAN: 0x0006; + static ZERO: 0; + ZERO: 0; + static ONE: 1; + ONE: 1; + static SRC_COLOR: 0x0300; + SRC_COLOR: 0x0300; + static ONE_MINUS_SRC_COLOR: 0x0301; + ONE_MINUS_SRC_COLOR: 0x0301; + static SRC_ALPHA: 0x0302; + SRC_ALPHA: 0x0302; + static ONE_MINUS_SRC_ALPHA: 0x0303; + ONE_MINUS_SRC_ALPHA: 0x0303; + static DST_ALPHA: 0x0304; + DST_ALPHA: 0x0304; + static ONE_MINUS_DST_ALPHA: 0x0305; + ONE_MINUS_DST_ALPHA: 0x0305; + static DST_COLOR: 0x0306; + DST_COLOR: 0x0306; + static ONE_MINUS_DST_COLOR: 0x0307; + ONE_MINUS_DST_COLOR: 0x0307; + static SRC_ALPHA_SATURATE: 0x0308; + SRC_ALPHA_SATURATE: 0x0308; + static FUNC_ADD: 0x8006; + FUNC_ADD: 0x8006; + static BLEND_EQUATION: 0x8009; + BLEND_EQUATION: 0x8009; + static BLEND_EQUATION_RGB: 0x8009; + BLEND_EQUATION_RGB: 0x8009; + static BLEND_EQUATION_ALPHA: 0x883d; + BLEND_EQUATION_ALPHA: 0x883d; + static FUNC_SUBTRACT: 0x800a; + FUNC_SUBTRACT: 0x800a; + static FUNC_REVERSE_SUBTRACT: 0x800b; + FUNC_REVERSE_SUBTRACT: 0x800b; + static BLEND_DST_RGB: 0x80c8; + BLEND_DST_RGB: 0x80c8; + static BLEND_SRC_RGB: 0x80c9; + BLEND_SRC_RGB: 0x80c9; + static BLEND_DST_ALPHA: 0x80ca; + BLEND_DST_ALPHA: 0x80ca; + static BLEND_SRC_ALPHA: 0x80cb; + BLEND_SRC_ALPHA: 0x80cb; + static CONSTANT_COLOR: 0x8001; + CONSTANT_COLOR: 0x8001; + static ONE_MINUS_CONSTANT_COLOR: 0x8002; + ONE_MINUS_CONSTANT_COLOR: 0x8002; + static CONSTANT_ALPHA: 0x8003; + CONSTANT_ALPHA: 0x8003; + static ONE_MINUS_CONSTANT_ALPHA: 0x8004; + ONE_MINUS_CONSTANT_ALPHA: 0x8004; + static BLEND_COLOR: 0x8005; + BLEND_COLOR: 0x8005; + static ARRAY_BUFFER: 0x8892; + ARRAY_BUFFER: 0x8892; + static ELEMENT_ARRAY_BUFFER: 0x8893; + ELEMENT_ARRAY_BUFFER: 0x8893; + static ARRAY_BUFFER_BINDING: 0x8894; + ARRAY_BUFFER_BINDING: 0x8894; + static ELEMENT_ARRAY_BUFFER_BINDING: 0x8895; + ELEMENT_ARRAY_BUFFER_BINDING: 0x8895; + static STREAM_DRAW: 0x88e0; + STREAM_DRAW: 0x88e0; + static STATIC_DRAW: 0x88e4; + STATIC_DRAW: 0x88e4; + static DYNAMIC_DRAW: 0x88e8; + DYNAMIC_DRAW: 0x88e8; + static BUFFER_SIZE: 0x8764; + BUFFER_SIZE: 0x8764; + static BUFFER_USAGE: 0x8765; + BUFFER_USAGE: 0x8765; + static CURRENT_VERTEX_ATTRIB: 0x8626; + CURRENT_VERTEX_ATTRIB: 0x8626; + static FRONT: 0x0404; + FRONT: 0x0404; + static BACK: 0x0405; + BACK: 0x0405; + static FRONT_AND_BACK: 0x0408; + FRONT_AND_BACK: 0x0408; + static CULL_FACE: 0x0b44; + CULL_FACE: 0x0b44; + static BLEND: 0x0be2; + BLEND: 0x0be2; + static DITHER: 0x0bd0; + DITHER: 0x0bd0; + static STENCIL_TEST: 0x0b90; + STENCIL_TEST: 0x0b90; + static DEPTH_TEST: 0x0b71; + DEPTH_TEST: 0x0b71; + static SCISSOR_TEST: 0x0c11; + SCISSOR_TEST: 0x0c11; + static POLYGON_OFFSET_FILL: 0x8037; + POLYGON_OFFSET_FILL: 0x8037; + static SAMPLE_ALPHA_TO_COVERAGE: 0x809e; + SAMPLE_ALPHA_TO_COVERAGE: 0x809e; + static SAMPLE_COVERAGE: 0x80a0; + SAMPLE_COVERAGE: 0x80a0; + static NO_ERROR: 0; + NO_ERROR: 0; + static INVALID_ENUM: 0x0500; + INVALID_ENUM: 0x0500; + static INVALID_VALUE: 0x0501; + INVALID_VALUE: 0x0501; + static INVALID_OPERATION: 0x0502; + INVALID_OPERATION: 0x0502; + static OUT_OF_MEMORY: 0x0505; + OUT_OF_MEMORY: 0x0505; + static CW: 0x0900; + CW: 0x0900; + static CCW: 0x0901; + CCW: 0x0901; + static LINE_WIDTH: 0x0b21; + LINE_WIDTH: 0x0b21; + static ALIASED_POINT_SIZE_RANGE: 0x846d; + ALIASED_POINT_SIZE_RANGE: 0x846d; + static ALIASED_LINE_WIDTH_RANGE: 0x846e; + ALIASED_LINE_WIDTH_RANGE: 0x846e; + static CULL_FACE_MODE: 0x0b45; + CULL_FACE_MODE: 0x0b45; + static FRONT_FACE: 0x0b46; + FRONT_FACE: 0x0b46; + static DEPTH_RANGE: 0x0b70; + DEPTH_RANGE: 0x0b70; + static DEPTH_WRITEMASK: 0x0b72; + DEPTH_WRITEMASK: 0x0b72; + static DEPTH_CLEAR_VALUE: 0x0b73; + DEPTH_CLEAR_VALUE: 0x0b73; + static DEPTH_FUNC: 0x0b74; + DEPTH_FUNC: 0x0b74; + static STENCIL_CLEAR_VALUE: 0x0b91; + STENCIL_CLEAR_VALUE: 0x0b91; + static STENCIL_FUNC: 0x0b92; + STENCIL_FUNC: 0x0b92; + static STENCIL_FAIL: 0x0b94; + STENCIL_FAIL: 0x0b94; + static STENCIL_PASS_DEPTH_FAIL: 0x0b95; + STENCIL_PASS_DEPTH_FAIL: 0x0b95; + static STENCIL_PASS_DEPTH_PASS: 0x0b96; + STENCIL_PASS_DEPTH_PASS: 0x0b96; + static STENCIL_REF: 0x0b97; + STENCIL_REF: 0x0b97; + static STENCIL_VALUE_MASK: 0x0b93; + STENCIL_VALUE_MASK: 0x0b93; + static STENCIL_WRITEMASK: 0x0b98; + STENCIL_WRITEMASK: 0x0b98; + static STENCIL_BACK_FUNC: 0x8800; + STENCIL_BACK_FUNC: 0x8800; + static STENCIL_BACK_FAIL: 0x8801; + STENCIL_BACK_FAIL: 0x8801; + static STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802; + STENCIL_BACK_PASS_DEPTH_FAIL: 0x8802; + static STENCIL_BACK_PASS_DEPTH_PASS: 0x8803; + STENCIL_BACK_PASS_DEPTH_PASS: 0x8803; + static STENCIL_BACK_REF: 0x8ca3; + STENCIL_BACK_REF: 0x8ca3; + static STENCIL_BACK_VALUE_MASK: 0x8ca4; + STENCIL_BACK_VALUE_MASK: 0x8ca4; + static STENCIL_BACK_WRITEMASK: 0x8ca5; + STENCIL_BACK_WRITEMASK: 0x8ca5; + static VIEWPORT: 0x0ba2; + VIEWPORT: 0x0ba2; + static SCISSOR_BOX: 0x0c10; + SCISSOR_BOX: 0x0c10; + static COLOR_CLEAR_VALUE: 0x0c22; + COLOR_CLEAR_VALUE: 0x0c22; + static COLOR_WRITEMASK: 0x0c23; + COLOR_WRITEMASK: 0x0c23; + static UNPACK_ALIGNMENT: 0x0cf5; + UNPACK_ALIGNMENT: 0x0cf5; + static PACK_ALIGNMENT: 0x0d05; + PACK_ALIGNMENT: 0x0d05; + static MAX_TEXTURE_SIZE: 0x0d33; + MAX_TEXTURE_SIZE: 0x0d33; + static MAX_VIEWPORT_DIMS: 0x0d3a; + MAX_VIEWPORT_DIMS: 0x0d3a; + static SUBPIXEL_BITS: 0x0d50; + SUBPIXEL_BITS: 0x0d50; + static RED_BITS: 0x0d52; + RED_BITS: 0x0d52; + static GREEN_BITS: 0x0d53; + GREEN_BITS: 0x0d53; + static BLUE_BITS: 0x0d54; + BLUE_BITS: 0x0d54; + static ALPHA_BITS: 0x0d55; + ALPHA_BITS: 0x0d55; + static DEPTH_BITS: 0x0d56; + DEPTH_BITS: 0x0d56; + static STENCIL_BITS: 0x0d57; + STENCIL_BITS: 0x0d57; + static POLYGON_OFFSET_UNITS: 0x2a00; + POLYGON_OFFSET_UNITS: 0x2a00; + static POLYGON_OFFSET_FACTOR: 0x8038; + POLYGON_OFFSET_FACTOR: 0x8038; + static TEXTURE_BINDING_2D: 0x8069; + TEXTURE_BINDING_2D: 0x8069; + static SAMPLE_BUFFERS: 0x80a8; + SAMPLE_BUFFERS: 0x80a8; + static SAMPLES: 0x80a9; + SAMPLES: 0x80a9; + static SAMPLE_COVERAGE_VALUE: 0x80aa; + SAMPLE_COVERAGE_VALUE: 0x80aa; + static SAMPLE_COVERAGE_INVERT: 0x80ab; + SAMPLE_COVERAGE_INVERT: 0x80ab; + static COMPRESSED_TEXTURE_FORMATS: 0x86a3; + COMPRESSED_TEXTURE_FORMATS: 0x86a3; + static DONT_CARE: 0x1100; + DONT_CARE: 0x1100; + static FASTEST: 0x1101; + FASTEST: 0x1101; + static NICEST: 0x1102; + NICEST: 0x1102; + static GENERATE_MIPMAP_HINT: 0x8192; + GENERATE_MIPMAP_HINT: 0x8192; + static BYTE: 0x1400; + BYTE: 0x1400; + static UNSIGNED_BYTE: 0x1401; + UNSIGNED_BYTE: 0x1401; + static SHORT: 0x1402; + SHORT: 0x1402; + static UNSIGNED_SHORT: 0x1403; + UNSIGNED_SHORT: 0x1403; + static INT: 0x1404; + INT: 0x1404; + static UNSIGNED_INT: 0x1405; + UNSIGNED_INT: 0x1405; + static FLOAT: 0x1406; + FLOAT: 0x1406; + static DEPTH_COMPONENT: 0x1902; + DEPTH_COMPONENT: 0x1902; + static ALPHA: 0x1906; + ALPHA: 0x1906; + static RGB: 0x1907; + RGB: 0x1907; + static RGBA: 0x1908; + RGBA: 0x1908; + static LUMINANCE: 0x1909; + LUMINANCE: 0x1909; + static LUMINANCE_ALPHA: 0x190a; + LUMINANCE_ALPHA: 0x190a; + static UNSIGNED_SHORT_4_4_4_4: 0x8033; + UNSIGNED_SHORT_4_4_4_4: 0x8033; + static UNSIGNED_SHORT_5_5_5_1: 0x8034; + UNSIGNED_SHORT_5_5_5_1: 0x8034; + static UNSIGNED_SHORT_5_6_5: 0x8363; + UNSIGNED_SHORT_5_6_5: 0x8363; + static FRAGMENT_SHADER: 0x8b30; + FRAGMENT_SHADER: 0x8b30; + static VERTEX_SHADER: 0x8b31; + VERTEX_SHADER: 0x8b31; + static MAX_VERTEX_ATTRIBS: 0x8869; + MAX_VERTEX_ATTRIBS: 0x8869; + static MAX_VERTEX_UNIFORM_VECTORS: 0x8dfb; + MAX_VERTEX_UNIFORM_VECTORS: 0x8dfb; + static MAX_VARYING_VECTORS: 0x8dfc; + MAX_VARYING_VECTORS: 0x8dfc; + static MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8b4d; + MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8b4d; + static MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8b4c; + MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8b4c; + static MAX_TEXTURE_IMAGE_UNITS: 0x8872; + MAX_TEXTURE_IMAGE_UNITS: 0x8872; + static MAX_FRAGMENT_UNIFORM_VECTORS: 0x8dfd; + MAX_FRAGMENT_UNIFORM_VECTORS: 0x8dfd; + static SHADER_TYPE: 0x8b4f; + SHADER_TYPE: 0x8b4f; + static DELETE_STATUS: 0x8b80; + DELETE_STATUS: 0x8b80; + static LINK_STATUS: 0x8b82; + LINK_STATUS: 0x8b82; + static VALIDATE_STATUS: 0x8b83; + VALIDATE_STATUS: 0x8b83; + static ATTACHED_SHADERS: 0x8b85; + ATTACHED_SHADERS: 0x8b85; + static ACTIVE_UNIFORMS: 0x8b86; + ACTIVE_UNIFORMS: 0x8b86; + static ACTIVE_ATTRIBUTES: 0x8b89; + ACTIVE_ATTRIBUTES: 0x8b89; + static SHADING_LANGUAGE_VERSION: 0x8b8c; + SHADING_LANGUAGE_VERSION: 0x8b8c; + static CURRENT_PROGRAM: 0x8b8d; + CURRENT_PROGRAM: 0x8b8d; + static NEVER: 0x0200; + NEVER: 0x0200; + static LESS: 0x0201; + LESS: 0x0201; + static EQUAL: 0x0202; + EQUAL: 0x0202; + static LEQUAL: 0x0203; + LEQUAL: 0x0203; + static GREATER: 0x0204; + GREATER: 0x0204; + static NOTEQUAL: 0x0205; + NOTEQUAL: 0x0205; + static GEQUAL: 0x0206; + GEQUAL: 0x0206; + static ALWAYS: 0x0207; + ALWAYS: 0x0207; + static KEEP: 0x1e00; + KEEP: 0x1e00; + static REPLACE: 0x1e01; + REPLACE: 0x1e01; + static INCR: 0x1e02; + INCR: 0x1e02; + static DECR: 0x1e03; + DECR: 0x1e03; + static INVERT: 0x150a; + INVERT: 0x150a; + static INCR_WRAP: 0x8507; + INCR_WRAP: 0x8507; + static DECR_WRAP: 0x8508; + DECR_WRAP: 0x8508; + static VENDOR: 0x1f00; + VENDOR: 0x1f00; + static RENDERER: 0x1f01; + RENDERER: 0x1f01; + static VERSION: 0x1f02; + VERSION: 0x1f02; + static NEAREST: 0x2600; + NEAREST: 0x2600; + static LINEAR: 0x2601; + LINEAR: 0x2601; + static NEAREST_MIPMAP_NEAREST: 0x2700; + NEAREST_MIPMAP_NEAREST: 0x2700; + static LINEAR_MIPMAP_NEAREST: 0x2701; + LINEAR_MIPMAP_NEAREST: 0x2701; + static NEAREST_MIPMAP_LINEAR: 0x2702; + NEAREST_MIPMAP_LINEAR: 0x2702; + static LINEAR_MIPMAP_LINEAR: 0x2703; + LINEAR_MIPMAP_LINEAR: 0x2703; + static TEXTURE_MAG_FILTER: 0x2800; + TEXTURE_MAG_FILTER: 0x2800; + static TEXTURE_MIN_FILTER: 0x2801; + TEXTURE_MIN_FILTER: 0x2801; + static TEXTURE_WRAP_S: 0x2802; + TEXTURE_WRAP_S: 0x2802; + static TEXTURE_WRAP_T: 0x2803; + TEXTURE_WRAP_T: 0x2803; + static TEXTURE_2D: 0x0de1; + TEXTURE_2D: 0x0de1; + static TEXTURE: 0x1702; + TEXTURE: 0x1702; + static TEXTURE_CUBE_MAP: 0x8513; + TEXTURE_CUBE_MAP: 0x8513; + static TEXTURE_BINDING_CUBE_MAP: 0x8514; + TEXTURE_BINDING_CUBE_MAP: 0x8514; + static TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515; + TEXTURE_CUBE_MAP_POSITIVE_X: 0x8515; + static TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516; + TEXTURE_CUBE_MAP_NEGATIVE_X: 0x8516; + static TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517; + TEXTURE_CUBE_MAP_POSITIVE_Y: 0x8517; + static TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518; + TEXTURE_CUBE_MAP_NEGATIVE_Y: 0x8518; + static TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519; + TEXTURE_CUBE_MAP_POSITIVE_Z: 0x8519; + static TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851a; + TEXTURE_CUBE_MAP_NEGATIVE_Z: 0x851a; + static MAX_CUBE_MAP_TEXTURE_SIZE: 0x851c; + MAX_CUBE_MAP_TEXTURE_SIZE: 0x851c; + static TEXTURE0: 0x84c0; + TEXTURE0: 0x84c0; + static TEXTURE1: 0x84c1; + TEXTURE1: 0x84c1; + static TEXTURE2: 0x84c2; + TEXTURE2: 0x84c2; + static TEXTURE3: 0x84c3; + TEXTURE3: 0x84c3; + static TEXTURE4: 0x84c4; + TEXTURE4: 0x84c4; + static TEXTURE5: 0x84c5; + TEXTURE5: 0x84c5; + static TEXTURE6: 0x84c6; + TEXTURE6: 0x84c6; + static TEXTURE7: 0x84c7; + TEXTURE7: 0x84c7; + static TEXTURE8: 0x84c8; + TEXTURE8: 0x84c8; + static TEXTURE9: 0x84c9; + TEXTURE9: 0x84c9; + static TEXTURE10: 0x84ca; + TEXTURE10: 0x84ca; + static TEXTURE11: 0x84cb; + TEXTURE11: 0x84cb; + static TEXTURE12: 0x84cc; + TEXTURE12: 0x84cc; + static TEXTURE13: 0x84cd; + TEXTURE13: 0x84cd; + static TEXTURE14: 0x84ce; + TEXTURE14: 0x84ce; + static TEXTURE15: 0x84cf; + TEXTURE15: 0x84cf; + static TEXTURE16: 0x84d0; + TEXTURE16: 0x84d0; + static TEXTURE17: 0x84d1; + TEXTURE17: 0x84d1; + static TEXTURE18: 0x84d2; + TEXTURE18: 0x84d2; + static TEXTURE19: 0x84d3; + TEXTURE19: 0x84d3; + static TEXTURE20: 0x84d4; + TEXTURE20: 0x84d4; + static TEXTURE21: 0x84d5; + TEXTURE21: 0x84d5; + static TEXTURE22: 0x84d6; + TEXTURE22: 0x84d6; + static TEXTURE23: 0x84d7; + TEXTURE23: 0x84d7; + static TEXTURE24: 0x84d8; + TEXTURE24: 0x84d8; + static TEXTURE25: 0x84d9; + TEXTURE25: 0x84d9; + static TEXTURE26: 0x84da; + TEXTURE26: 0x84da; + static TEXTURE27: 0x84db; + TEXTURE27: 0x84db; + static TEXTURE28: 0x84dc; + TEXTURE28: 0x84dc; + static TEXTURE29: 0x84dd; + TEXTURE29: 0x84dd; + static TEXTURE30: 0x84de; + TEXTURE30: 0x84de; + static TEXTURE31: 0x84df; + TEXTURE31: 0x84df; + static ACTIVE_TEXTURE: 0x84e0; + ACTIVE_TEXTURE: 0x84e0; + static REPEAT: 0x2901; + REPEAT: 0x2901; + static CLAMP_TO_EDGE: 0x812f; + CLAMP_TO_EDGE: 0x812f; + static MIRRORED_REPEAT: 0x8370; + MIRRORED_REPEAT: 0x8370; + static FLOAT_VEC2: 0x8b50; + FLOAT_VEC2: 0x8b50; + static FLOAT_VEC3: 0x8b51; + FLOAT_VEC3: 0x8b51; + static FLOAT_VEC4: 0x8b52; + FLOAT_VEC4: 0x8b52; + static INT_VEC2: 0x8b53; + INT_VEC2: 0x8b53; + static INT_VEC3: 0x8b54; + INT_VEC3: 0x8b54; + static INT_VEC4: 0x8b55; + INT_VEC4: 0x8b55; + static BOOL: 0x8b56; + BOOL: 0x8b56; + static BOOL_VEC2: 0x8b57; + BOOL_VEC2: 0x8b57; + static BOOL_VEC3: 0x8b58; + BOOL_VEC3: 0x8b58; + static BOOL_VEC4: 0x8b59; + BOOL_VEC4: 0x8b59; + static FLOAT_MAT2: 0x8b5a; + FLOAT_MAT2: 0x8b5a; + static FLOAT_MAT3: 0x8b5b; + FLOAT_MAT3: 0x8b5b; + static FLOAT_MAT4: 0x8b5c; + FLOAT_MAT4: 0x8b5c; + static SAMPLER_2D: 0x8b5e; + SAMPLER_2D: 0x8b5e; + static SAMPLER_CUBE: 0x8b60; + SAMPLER_CUBE: 0x8b60; + static VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622; + VERTEX_ATTRIB_ARRAY_ENABLED: 0x8622; + static VERTEX_ATTRIB_ARRAY_SIZE: 0x8623; + VERTEX_ATTRIB_ARRAY_SIZE: 0x8623; + static VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624; + VERTEX_ATTRIB_ARRAY_STRIDE: 0x8624; + static VERTEX_ATTRIB_ARRAY_TYPE: 0x8625; + VERTEX_ATTRIB_ARRAY_TYPE: 0x8625; + static VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886a; + VERTEX_ATTRIB_ARRAY_NORMALIZED: 0x886a; + static VERTEX_ATTRIB_ARRAY_POINTER: 0x8645; + VERTEX_ATTRIB_ARRAY_POINTER: 0x8645; + static VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889f; + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: 0x889f; + static IMPLEMENTATION_COLOR_READ_TYPE: 0x8b9a; + IMPLEMENTATION_COLOR_READ_TYPE: 0x8b9a; + static IMPLEMENTATION_COLOR_READ_FORMAT: 0x8b9b; + IMPLEMENTATION_COLOR_READ_FORMAT: 0x8b9b; + static COMPILE_STATUS: 0x8b81; + COMPILE_STATUS: 0x8b81; + static LOW_FLOAT: 0x8df0; + LOW_FLOAT: 0x8df0; + static MEDIUM_FLOAT: 0x8df1; + MEDIUM_FLOAT: 0x8df1; + static HIGH_FLOAT: 0x8df2; + HIGH_FLOAT: 0x8df2; + static LOW_INT: 0x8df3; + LOW_INT: 0x8df3; + static MEDIUM_INT: 0x8df4; + MEDIUM_INT: 0x8df4; + static HIGH_INT: 0x8df5; + HIGH_INT: 0x8df5; + static FRAMEBUFFER: 0x8d40; + FRAMEBUFFER: 0x8d40; + static RENDERBUFFER: 0x8d41; + RENDERBUFFER: 0x8d41; + static RGBA4: 0x8056; + RGBA4: 0x8056; + static RGB5_A1: 0x8057; + RGB5_A1: 0x8057; + static RGB565: 0x8d62; + RGB565: 0x8d62; + static DEPTH_COMPONENT16: 0x81a5; + DEPTH_COMPONENT16: 0x81a5; + static STENCIL_INDEX: 0x1901; + STENCIL_INDEX: 0x1901; + static STENCIL_INDEX8: 0x8d48; + STENCIL_INDEX8: 0x8d48; + static DEPTH_STENCIL: 0x84f9; + DEPTH_STENCIL: 0x84f9; + static RENDERBUFFER_WIDTH: 0x8d42; + RENDERBUFFER_WIDTH: 0x8d42; + static RENDERBUFFER_HEIGHT: 0x8d43; + RENDERBUFFER_HEIGHT: 0x8d43; + static RENDERBUFFER_INTERNAL_FORMAT: 0x8d44; + RENDERBUFFER_INTERNAL_FORMAT: 0x8d44; + static RENDERBUFFER_RED_SIZE: 0x8d50; + RENDERBUFFER_RED_SIZE: 0x8d50; + static RENDERBUFFER_GREEN_SIZE: 0x8d51; + RENDERBUFFER_GREEN_SIZE: 0x8d51; + static RENDERBUFFER_BLUE_SIZE: 0x8d52; + RENDERBUFFER_BLUE_SIZE: 0x8d52; + static RENDERBUFFER_ALPHA_SIZE: 0x8d53; + RENDERBUFFER_ALPHA_SIZE: 0x8d53; + static RENDERBUFFER_DEPTH_SIZE: 0x8d54; + RENDERBUFFER_DEPTH_SIZE: 0x8d54; + static RENDERBUFFER_STENCIL_SIZE: 0x8d55; + RENDERBUFFER_STENCIL_SIZE: 0x8d55; + static FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8cd0; + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: 0x8cd0; + static FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8cd1; + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: 0x8cd1; + static FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8cd2; + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: 0x8cd2; + static FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8cd3; + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: 0x8cd3; + static COLOR_ATTACHMENT0: 0x8ce0; + COLOR_ATTACHMENT0: 0x8ce0; + static DEPTH_ATTACHMENT: 0x8d00; + DEPTH_ATTACHMENT: 0x8d00; + static STENCIL_ATTACHMENT: 0x8d20; + STENCIL_ATTACHMENT: 0x8d20; + static DEPTH_STENCIL_ATTACHMENT: 0x821a; + DEPTH_STENCIL_ATTACHMENT: 0x821a; + static NONE: 0; + NONE: 0; + static FRAMEBUFFER_COMPLETE: 0x8cd5; + FRAMEBUFFER_COMPLETE: 0x8cd5; + static FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6; + FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6; + static FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7; + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7; + static FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9; + FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9; + static FRAMEBUFFER_UNSUPPORTED: 0x8cdd; + FRAMEBUFFER_UNSUPPORTED: 0x8cdd; + static FRAMEBUFFER_BINDING: 0x8ca6; + FRAMEBUFFER_BINDING: 0x8ca6; + static RENDERBUFFER_BINDING: 0x8ca7; + RENDERBUFFER_BINDING: 0x8ca7; + static MAX_RENDERBUFFER_SIZE: 0x84e8; + MAX_RENDERBUFFER_SIZE: 0x84e8; + static INVALID_FRAMEBUFFER_OPERATION: 0x0506; + INVALID_FRAMEBUFFER_OPERATION: 0x0506; + static UNPACK_FLIP_Y_WEBGL: 0x9240; + UNPACK_FLIP_Y_WEBGL: 0x9240; + static UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241; + UNPACK_PREMULTIPLY_ALPHA_WEBGL: 0x9241; + static CONTEXT_LOST_WEBGL: 0x9242; + CONTEXT_LOST_WEBGL: 0x9242; + static UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243; + UNPACK_COLORSPACE_CONVERSION_WEBGL: 0x9243; + static BROWSER_DEFAULT_WEBGL: 0x9244; + BROWSER_DEFAULT_WEBGL: 0x9244; + + canvas: HTMLCanvasElement; + drawingBufferWidth: number; + drawingBufferHeight: number; + + getContextAttributes(): ?WebGLContextAttributes; + isContextLost(): boolean; + + getSupportedExtensions(): ?Array; + getExtension(name: string): any; + + activeTexture(texture: number): void; + attachShader(program: WebGLProgram, shader: WebGLShader): void; + bindAttribLocation(program: WebGLProgram, index: number, name: string): void; + bindBuffer(target: number, buffer: ?WebGLBuffer): void; + bindFramebuffer(target: number, framebuffer: ?WebGLFramebuffer): void; + bindRenderbuffer(target: number, renderbuffer: ?WebGLRenderbuffer): void; + bindTexture(target: number, texture: ?WebGLTexture): void; + blendColor(red: number, green: number, blue: number, alpha: number): void; + blendEquation(mode: number): void; + blendEquationSeparate(modeRGB: number, modeAlpha: number): void; + blendFunc(sfactor: number, dfactor: number): void; + blendFuncSeparate( + srcRGB: number, + dstRGB: number, + srcAlpha: number, + dstAlpha: number + ): void; + + bufferData(target: number, size: number, usage: number): void; + bufferData(target: number, data: ?ArrayBuffer, usage: number): void; + bufferData(target: number, data: $ArrayBufferView, usage: number): void; + bufferSubData(target: number, offset: number, data: BufferDataSource): void; + + checkFramebufferStatus(target: number): number; + clear(mask: number): void; + clearColor(red: number, green: number, blue: number, alpha: number): void; + clearDepth(depth: number): void; + clearStencil(s: number): void; + colorMask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void; + compileShader(shader: WebGLShader): void; + + compressedTexImage2D( + target: number, + level: number, + internalformat: number, + width: number, + height: number, + border: number, + data: $ArrayBufferView + ): void; + + compressedTexSubImage2D( + target: number, + level: number, + xoffset: number, + yoffset: number, + width: number, + height: number, + format: number, + data: $ArrayBufferView + ): void; + + copyTexImage2D( + target: number, + level: number, + internalformat: number, + x: number, + y: number, + width: number, + height: number, + border: number + ): void; + copyTexSubImage2D( + target: number, + level: number, + xoffset: number, + yoffset: number, + x: number, + y: number, + width: number, + height: number + ): void; + + createBuffer(): ?WebGLBuffer; + createFramebuffer(): ?WebGLFramebuffer; + createProgram(): ?WebGLProgram; + createRenderbuffer(): ?WebGLRenderbuffer; + createShader(type: number): ?WebGLShader; + createTexture(): ?WebGLTexture; + + cullFace(mode: number): void; + + deleteBuffer(buffer: ?WebGLBuffer): void; + deleteFramebuffer(framebuffer: ?WebGLFramebuffer): void; + deleteProgram(program: ?WebGLProgram): void; + deleteRenderbuffer(renderbuffer: ?WebGLRenderbuffer): void; + deleteShader(shader: ?WebGLShader): void; + deleteTexture(texture: ?WebGLTexture): void; + + depthFunc(func: number): void; + depthMask(flag: boolean): void; + depthRange(zNear: number, zFar: number): void; + detachShader(program: WebGLProgram, shader: WebGLShader): void; + disable(cap: number): void; + disableVertexAttribArray(index: number): void; + drawArrays(mode: number, first: number, count: number): void; + drawElements(mode: number, count: number, type: number, offset: number): void; + + enable(cap: number): void; + enableVertexAttribArray(index: number): void; + finish(): void; + flush(): void; + framebufferRenderbuffer( + target: number, + attachment: number, + renderbuffertarget: number, + renderbuffer: ?WebGLRenderbuffer + ): void; + framebufferTexture2D( + target: number, + attachment: number, + textarget: number, + texture: ?WebGLTexture, + level: number + ): void; + frontFace(mode: number): void; + + generateMipmap(target: number): void; + + getActiveAttrib(program: WebGLProgram, index: number): ?WebGLActiveInfo; + getActiveUniform(program: WebGLProgram, index: number): ?WebGLActiveInfo; + getAttachedShaders(program: WebGLProgram): ?Array; + + getAttribLocation(program: WebGLProgram, name: string): number; + + getBufferParameter(target: number, pname: number): any; + getParameter(pname: number): any; + + getError(): number; + + getFramebufferAttachmentParameter( + target: number, + attachment: number, + pname: number + ): any; + getProgramParameter(program: WebGLProgram, pname: number): any; + getProgramInfoLog(program: WebGLProgram): ?string; + getRenderbufferParameter(target: number, pname: number): any; + getShaderParameter(shader: WebGLShader, pname: number): any; + getShaderPrecisionFormat( + shadertype: number, + precisiontype: number + ): ?WebGLShaderPrecisionFormat; + getShaderInfoLog(shader: WebGLShader): ?string; + + getShaderSource(shader: WebGLShader): ?string; + + getTexParameter(target: number, pname: number): any; + + getUniform(program: WebGLProgram, location: WebGLUniformLocation): any; + + getUniformLocation( + program: WebGLProgram, + name: string + ): ?WebGLUniformLocation; + + getVertexAttrib(index: number, pname: number): any; + + getVertexAttribOffset(index: number, pname: number): number; + + hint(target: number, mode: number): void; + isBuffer(buffer: ?WebGLBuffer): boolean; + isEnabled(cap: number): boolean; + isFramebuffer(framebuffer: ?WebGLFramebuffer): boolean; + isProgram(program: ?WebGLProgram): boolean; + isRenderbuffer(renderbuffer: ?WebGLRenderbuffer): boolean; + isShader(shader: ?WebGLShader): boolean; + isTexture(texture: ?WebGLTexture): boolean; + lineWidth(width: number): void; + linkProgram(program: WebGLProgram): void; + pixelStorei(pname: number, param: number): void; + polygonOffset(factor: number, units: number): void; + + readPixels( + x: number, + y: number, + width: number, + height: number, + format: number, + type: number, + pixels: ?$ArrayBufferView + ): void; + + renderbufferStorage( + target: number, + internalformat: number, + width: number, + height: number + ): void; + sampleCoverage(value: number, invert: boolean): void; + scissor(x: number, y: number, width: number, height: number): void; + + shaderSource(shader: WebGLShader, source: string): void; + + stencilFunc(func: number, ref: number, mask: number): void; + stencilFuncSeparate( + face: number, + func: number, + ref: number, + mask: number + ): void; + stencilMask(mask: number): void; + stencilMaskSeparate(face: number, mask: number): void; + stencilOp(fail: number, zfail: number, zpass: number): void; + stencilOpSeparate( + face: number, + fail: number, + zfail: number, + zpass: number + ): void; + + texImage2D( + target: number, + level: number, + internalformat: number, + width: number, + height: number, + border: number, + format: number, + type: number, + pixels: ?$ArrayBufferView + ): void; + texImage2D( + target: number, + level: number, + internalformat: number, + format: number, + type: number, + source: TexImageSource + ): void; + + texParameterf(target: number, pname: number, param: number): void; + texParameteri(target: number, pname: number, param: number): void; + + texSubImage2D( + target: number, + level: number, + xoffset: number, + yoffset: number, + width: number, + height: number, + format: number, + type: number, + pixels: ?$ArrayBufferView + ): void; + texSubImage2D( + target: number, + level: number, + xoffset: number, + yoffset: number, + format: number, + type: number, + source: TexImageSource + ): void; + + uniform1f(location: ?WebGLUniformLocation, x: number): void; + uniform1fv(location: ?WebGLUniformLocation, v: Float32Array): void; + uniform1fv(location: ?WebGLUniformLocation, v: Array): void; + uniform1fv(location: ?WebGLUniformLocation, v: [number]): void; + uniform1i(location: ?WebGLUniformLocation, x: number): void; + uniform1iv(location: ?WebGLUniformLocation, v: Int32Array): void; + uniform1iv(location: ?WebGLUniformLocation, v: Array): void; + uniform1iv(location: ?WebGLUniformLocation, v: [number]): void; + uniform2f(location: ?WebGLUniformLocation, x: number, y: number): void; + uniform2fv(location: ?WebGLUniformLocation, v: Float32Array): void; + uniform2fv(location: ?WebGLUniformLocation, v: Array): void; + uniform2fv(location: ?WebGLUniformLocation, v: [number, number]): void; + uniform2i(location: ?WebGLUniformLocation, x: number, y: number): void; + uniform2iv(location: ?WebGLUniformLocation, v: Int32Array): void; + uniform2iv(location: ?WebGLUniformLocation, v: Array): void; + uniform2iv(location: ?WebGLUniformLocation, v: [number, number]): void; + uniform3f( + location: ?WebGLUniformLocation, + x: number, + y: number, + z: number + ): void; + uniform3fv(location: ?WebGLUniformLocation, v: Float32Array): void; + uniform3fv(location: ?WebGLUniformLocation, v: Array): void; + uniform3fv( + location: ?WebGLUniformLocation, + v: [number, number, number] + ): void; + uniform3i( + location: ?WebGLUniformLocation, + x: number, + y: number, + z: number + ): void; + uniform3iv(location: ?WebGLUniformLocation, v: Int32Array): void; + uniform3iv(location: ?WebGLUniformLocation, v: Array): void; + uniform3iv( + location: ?WebGLUniformLocation, + v: [number, number, number] + ): void; + uniform4f( + location: ?WebGLUniformLocation, + x: number, + y: number, + z: number, + w: number + ): void; + uniform4fv(location: ?WebGLUniformLocation, v: Float32Array): void; + uniform4fv(location: ?WebGLUniformLocation, v: Array): void; + uniform4fv( + location: ?WebGLUniformLocation, + v: [number, number, number, number] + ): void; + uniform4i( + location: ?WebGLUniformLocation, + x: number, + y: number, + z: number, + w: number + ): void; + uniform4iv(location: ?WebGLUniformLocation, v: Int32Array): void; + uniform4iv(location: ?WebGLUniformLocation, v: Array): void; + uniform4iv( + location: ?WebGLUniformLocation, + v: [number, number, number, number] + ): void; + + uniformMatrix2fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Float32Array + ): void; + uniformMatrix2fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Array + ): void; + uniformMatrix3fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Float32Array + ): void; + uniformMatrix3fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Array + ): void; + uniformMatrix4fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Float32Array + ): void; + uniformMatrix4fv( + location: ?WebGLUniformLocation, + transpose: boolean, + value: Array + ): void; + + useProgram(program: ?WebGLProgram): void; + validateProgram(program: WebGLProgram): void; + + vertexAttrib1f(index: number, x: number): void; + vertexAttrib1fv(index: number, values: VertexAttribFVSource): void; + vertexAttrib2f(index: number, x: number, y: number): void; + vertexAttrib2fv(index: number, values: VertexAttribFVSource): void; + vertexAttrib3f(index: number, x: number, y: number, z: number): void; + vertexAttrib3fv(index: number, values: VertexAttribFVSource): void; + vertexAttrib4f( + index: number, + x: number, + y: number, + z: number, + w: number + ): void; + vertexAttrib4fv(index: number, values: VertexAttribFVSource): void; + vertexAttribPointer( + index: number, + size: number, + type: number, + normalized: boolean, + stride: number, + offset: number + ): void; + + viewport(x: number, y: number, width: number, height: number): void; +} + +declare class WebGLContextEvent extends Event { + statusMessage: string; +} + +declare class MediaKeyStatusMap { + @@iterator(): Iterator<[BufferDataSource, MediaKeyStatus]>; + size: number; + entries(): Iterator<[BufferDataSource, MediaKeyStatus]>; + forEach( + callbackfn: ( + value: MediaKeyStatus, + key: BufferDataSource, + map: MediaKeyStatusMap + ) => any, + thisArg?: any + ): void; + get(key: BufferDataSource): MediaKeyStatus; + has(key: BufferDataSource): boolean; + keys(): Iterator; + values(): Iterator; +} + +declare class MediaKeySession extends EventTarget { + sessionId: string; + expiration: number; + closed: Promise; + keyStatuses: MediaKeyStatusMap; + + generateRequest( + initDataType: string, + initData: BufferDataSource + ): Promise; + load(sessionId: string): Promise; + update(response: BufferDataSource): Promise; + close(): Promise; + remove(): Promise; + + onkeystatuschange: (ev: any) => any; + onmessage: (ev: any) => any; +} + +declare class MediaKeys { + createSession(mediaKeySessionType: MediaKeySessionType): MediaKeySession; + setServerCertificate(serverCertificate: BufferDataSource): Promise; +} + +declare class TextRange { + boundingLeft: number; + htmlText: string; + offsetLeft: number; + boundingWidth: number; + boundingHeight: number; + boundingTop: number; + text: string; + offsetTop: number; + moveToPoint(x: number, y: number): void; + queryCommandValue(cmdID: string): any; + getBookmark(): string; + move(unit: string, count?: number): number; + queryCommandIndeterm(cmdID: string): boolean; + scrollIntoView(fStart?: boolean): void; + findText(string: string, count?: number, flags?: number): boolean; + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean; + getBoundingClientRect(): DOMRect; + moveToBookmark(bookmark: string): boolean; + isEqual(range: TextRange): boolean; + duplicate(): TextRange; + collapse(start?: boolean): void; + queryCommandText(cmdID: string): string; + select(): void; + pasteHTML(html: string): void; + inRange(range: TextRange): boolean; + moveEnd(unit: string, count?: number): number; + getClientRects(): DOMRectList; + moveStart(unit: string, count?: number): number; + parentElement(): Element; + queryCommandState(cmdID: string): boolean; + compareEndPoints(how: string, sourceRange: TextRange): number; + execCommandShowHelp(cmdID: string): boolean; + moveToElementText(element: Element): void; + expand(Unit: string): boolean; + queryCommandSupported(cmdID: string): boolean; + setEndPoint(how: string, SourceRange: TextRange): void; + queryCommandEnabled(cmdID: string): boolean; +} + +// These types used to exist as a copy of DOMRect/DOMRectList, which is +// incorrect because there are no ClientRect/ClientRectList globals on the DOM. +// Keep these as type aliases for backwards compatibility. +declare type ClientRect = DOMRect; +declare type ClientRectList = DOMRectList; + +// TODO: HTML*Element + +declare class DOMImplementation { + createDocumentType( + qualifiedName: string, + publicId: string, + systemId: string + ): DocumentType; + createDocument( + namespaceURI: string | null, + qualifiedName: string, + doctype?: DocumentType | null + ): Document; + hasFeature(feature: string, version?: string): boolean; + + // non-standard + createHTMLDocument(title?: string): Document; +} + +declare class DocumentType extends Node { + name: string; + notations: NamedNodeMap; + systemId: string; + internalSubset: string; + entities: NamedNodeMap; + publicId: string; + + // from ChildNode interface + after(...nodes: Array): void; + before(...nodes: Array): void; + replaceWith(...nodes: Array): void; + remove(): void; +} + +declare class CharacterData extends Node { + length: number; + data: string; + deleteData(offset: number, count: number): void; + replaceData(offset: number, count: number, arg: string): void; + appendData(arg: string): void; + insertData(offset: number, arg: string): void; + substringData(offset: number, count: number): string; + + // from ChildNode interface + after(...nodes: Array): void; + before(...nodes: Array): void; + replaceWith(...nodes: Array): void; + remove(): void; +} + +declare class Text extends CharacterData { + assignedSlot?: HTMLSlotElement; + wholeText: string; + splitText(offset: number): Text; + replaceWholeText(content: string): Text; +} + +declare class Comment extends CharacterData { + text: string; +} + +declare class URL { + static canParse(url: string, base?: string): boolean; + static createObjectURL(blob: Blob): string; + static createObjectURL(mediaSource: MediaSource): string; + static revokeObjectURL(url: string): void; + static parse(url: string, base?: string): URL | null; + constructor(url: string, base?: string | URL): void; + hash: string; + host: string; + hostname: string; + href: string; + +origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + search: string; + +searchParams: URLSearchParams; + username: string; + toString(): string; + toJSON(): string; +} + +declare interface MediaSourceHandle {} + +declare class MediaSource extends EventTarget { + sourceBuffers: SourceBufferList; + activeSourceBuffers: SourceBufferList; + // https://w3c.github.io/media-source/#dom-readystate + readyState: 'closed' | 'open' | 'ended'; + duration: number; + handle: MediaSourceHandle; + addSourceBuffer(type: string): SourceBuffer; + removeSourceBuffer(sourceBuffer: SourceBuffer): void; + endOfStream(error?: string): void; + static isTypeSupported(type: string): boolean; +} + +declare class SourceBuffer extends EventTarget { + mode: 'segments' | 'sequence'; + updating: boolean; + buffered: TimeRanges; + timestampOffset: number; + audioTracks: AudioTrackList; + videoTracks: VideoTrackList; + textTracks: TextTrackList; + appendWindowStart: number; + appendWindowEnd: number; + + appendBuffer(data: ArrayBuffer | $ArrayBufferView): void; + // TODO: Add ReadableStream + // appendStream(stream: ReadableStream, maxSize?: number): void; + abort(): void; + remove(start: number, end: number): void; + + trackDefaults: TrackDefaultList; +} + +declare class SourceBufferList extends EventTarget { + @@iterator(): Iterator; + [index: number]: SourceBuffer; + length: number; +} + +declare class TrackDefaultList { + [index: number]: TrackDefault; + length: number; +} + +declare class TrackDefault { + type: 'audio' | 'video' | 'text'; + byteStreamTrackID: string; + language: string; + label: string; + kinds: Array; +} + +// TODO: The use of `typeof` makes this function signature effectively +// (node: Node) => number, but it should be (node: Node) => 1|2|3 +type NodeFilterCallback = ( + node: Node +) => + | typeof NodeFilter.FILTER_ACCEPT + | typeof NodeFilter.FILTER_REJECT + | typeof NodeFilter.FILTER_SKIP; + +type NodeFilterInterface = + | NodeFilterCallback + | {acceptNode: NodeFilterCallback, ...}; + +// TODO: window.NodeFilter exists at runtime and behaves as a constructor +// as far as `instanceof` is concerned, but it is not callable. +declare class NodeFilter { + static SHOW_ALL: -1; + static SHOW_ELEMENT: 1; + static SHOW_ATTRIBUTE: 2; // deprecated + static SHOW_TEXT: 4; + static SHOW_CDATA_SECTION: 8; // deprecated + static SHOW_ENTITY_REFERENCE: 16; // deprecated + static SHOW_ENTITY: 32; // deprecated + static SHOW_PROCESSING_INSTRUCTION: 64; + static SHOW_COMMENT: 128; + static SHOW_DOCUMENT: 256; + static SHOW_DOCUMENT_TYPE: 512; + static SHOW_DOCUMENT_FRAGMENT: 1024; + static SHOW_NOTATION: 2048; // deprecated + static FILTER_ACCEPT: 1; + static FILTER_REJECT: 2; + static FILTER_SKIP: 3; + acceptNode: NodeFilterCallback; +} + +// TODO: window.NodeIterator exists at runtime and behaves as a constructor +// as far as `instanceof` is concerned, but it is not callable. +declare class NodeIterator { + root: RootNodeT; + whatToShow: number; + filter: NodeFilter; + expandEntityReferences: boolean; + referenceNode: RootNodeT | WhatToShowT; + pointerBeforeReferenceNode: boolean; + detach(): void; + previousNode(): WhatToShowT | null; + nextNode(): WhatToShowT | null; +} + +// TODO: window.TreeWalker exists at runtime and behaves as a constructor +// as far as `instanceof` is concerned, but it is not callable. +declare class TreeWalker { + root: RootNodeT; + whatToShow: number; + filter: NodeFilter; + expandEntityReferences: boolean; + currentNode: RootNodeT | WhatToShowT; + parentNode(): WhatToShowT | null; + firstChild(): WhatToShowT | null; + lastChild(): WhatToShowT | null; + previousSibling(): WhatToShowT | null; + nextSibling(): WhatToShowT | null; + previousNode(): WhatToShowT | null; + nextNode(): WhatToShowT | null; +} + +/* Window file picker */ + +type WindowFileSystemPickerFileType = {| + description?: string, + /* + * An Object with the keys set to the MIME type + * and the values an Array of file extensions + * Example: + * accept: { + * "image/*": [".png", ".gif", ".jpeg", ".jpg"], + * }, + */ + accept: { + [string]: Array, + }, +|}; + +type WindowBaseFilePickerOptions = {| + id?: number, + startIn?: + | FileSystemHandle + | 'desktop' + | 'documents' + | 'downloads' + | 'music' + | 'pictures' + | 'videos', +|}; + +type WindowFilePickerOptions = WindowBaseFilePickerOptions & {| + excludeAcceptAllOption?: boolean, + types?: Array, +|}; + +type WindowOpenFilePickerOptions = WindowFilePickerOptions & {| + multiple?: boolean, +|}; + +type WindowSaveFilePickerOptions = WindowFilePickerOptions & {| + suggestedName?: string, +|}; + +type WindowDirectoryFilePickerOptions = WindowBaseFilePickerOptions & {| + mode?: 'read' | 'readwrite', +|}; + +// https://wicg.github.io/file-system-access/#api-showopenfilepicker +declare function showOpenFilePicker( + options?: WindowOpenFilePickerOptions +): Promise>; + +// https://wicg.github.io/file-system-access/#api-showsavefilepicker +declare function showSaveFilePicker( + options?: WindowSaveFilePickerOptions +): Promise; + +// https://wicg.github.io/file-system-access/#api-showdirectorypicker +declare function showDirectoryPicker( + options?: WindowDirectoryFilePickerOptions +): Promise; + +/* Notification */ +type NotificationPermission = 'default' | 'denied' | 'granted'; +type NotificationDirection = 'auto' | 'ltr' | 'rtl'; +type VibratePattern = number | Array; +type NotificationAction = { + action: string, + title: string, + icon?: string, + ... +}; +type NotificationOptions = { + dir?: NotificationDirection, + lang?: string, + body?: string, + tag?: string, + image?: string, + icon?: string, + badge?: string, + sound?: string, + vibrate?: VibratePattern, + timestamp?: number, + renotify?: boolean, + silent?: boolean, + requireInteraction?: boolean, + data?: ?any, + actions?: Array, + ... +}; + +declare class Notification extends EventTarget { + constructor(title: string, options?: NotificationOptions): void; + static +permission: NotificationPermission; + static requestPermission( + callback?: (perm: NotificationPermission) => mixed + ): Promise; + static +maxActions: number; + onclick: ?(evt: Event) => mixed; + onclose: ?(evt: Event) => mixed; + onerror: ?(evt: Event) => mixed; + onshow: ?(evt: Event) => mixed; + +title: string; + +dir: NotificationDirection; + +lang: string; + +body: string; + +tag: string; + +image?: string; + +icon?: string; + +badge?: string; + +vibrate?: Array; + +timestamp: number; + +renotify: boolean; + +silent: boolean; + +requireInteraction: boolean; + +data: any; + +actions: Array; + + close(): void; +} diff --git a/flow-typed/environments/geometry.js b/flow-typed/environments/geometry.js new file mode 100644 index 0000000000000..dbdd50267b3d0 --- /dev/null +++ b/flow-typed/environments/geometry.js @@ -0,0 +1,270 @@ +// flow-typed signature: c29a716c1825927cdfc3ad29fe929754 +// flow-typed version: 52ab99c6db/geometry/flow_>=v0.261.x + +// https://www.w3.org/TR/geometry-1/ + +type DOMMatrix2DInit = + | {| + a: number, + b: number, + c: number, + d: number, + e: number, + f: number, + |} + | {| + m11: number, + m12: number, + m21: number, + m22: number, + m41: number, + m42: number, + |}; + +type DOMMatrixInit = + | {| + ...DOMMatrix2DInit, + is2D: true, + |} + | {| + ...DOMMatrix2DInit, + is2D: false, + m13: number, + m14: number, + m23: number, + m24: number, + m31: number, + m32: number, + m33: number, + m34: number, + m43: number, + m44: number, + |}; + +type DOMPointInit = {| + w: number, + x: number, + y: number, + z: number, +|}; + +type DOMQuadInit = {| + p1: DOMPointInit, + p2: DOMPointInit, + p3: DOMPointInit, + p4: DOMPointInit, +|}; + +type DOMRectInit = {| + height: number, + width: number, + x: number, + y: number, +|}; + +declare class DOMMatrix extends DOMMatrixReadOnly { + a: number; + b: number; + c: number; + d: number; + e: number; + f: number; + m11: number; + m12: number; + m13: number; + m14: number; + m21: number; + m22: number; + m23: number; + m24: number; + m31: number; + m32: number; + m33: number; + m34: number; + m41: number; + m42: number; + m43: number; + m44: number; + + static fromFloat32Array(array32: Float32Array): DOMMatrix; + static fromFloat64Array(array64: Float64Array): DOMMatrix; + static fromMatrix(other?: DOMMatrixInit): DOMMatrix; + + constructor(init?: string | Array): void; + invertSelf(): DOMMatrix; + multiplySelf(other?: DOMMatrixInit): DOMMatrix; + preMultiplySelf(other?: DOMMatrixInit): DOMMatrix; + rotateAxisAngleSelf( + x?: number, + y?: number, + z?: number, + angle?: number + ): DOMMatrix; + rotateFromVectorSelf(x?: number, y?: number): DOMMatrix; + rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix; + scale3dSelf( + scale?: number, + originX?: number, + originY?: number, + originZ?: number + ): DOMMatrix; + scaleSelf( + scaleX?: number, + scaleY?: number, + scaleZ?: number, + originX?: number, + originY?: number, + originZ?: number + ): DOMMatrix; + setMatrixValue(transformList: string): DOMMatrix; + skewXSelf(sx?: number): DOMMatrix; + skewYSelf(sy?: number): DOMMatrix; + translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix; +} + +declare class DOMMatrixReadOnly { + +a: number; + +b: number; + +c: number; + +d: number; + +e: number; + +f: number; + +is2D: boolean; + +isIdentity: boolean; + +m11: number; + +m12: number; + +m13: number; + +m14: number; + +m21: number; + +m22: number; + +m23: number; + +m24: number; + +m31: number; + +m32: number; + +m33: number; + +m34: number; + +m41: number; + +m42: number; + +m43: number; + +m44: number; + + static fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly; + static fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly; + static fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly; + + constructor(init?: string | Array): void; + flipX(): DOMMatrix; + flipY(): DOMMatrix; + inverse(): DOMMatrix; + multiply(other?: DOMMatrixInit): DOMMatrix; + rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix; + rotateAxisAngle( + x?: number, + y?: number, + z?: number, + angle?: number + ): DOMMatrix; + rotateFromVector(x?: number, y?: number): DOMMatrix; + scale( + scaleX?: number, + scaleY?: number, + scaleZ?: number, + originX?: number, + originY?: number, + originZ?: number + ): DOMMatrix; + scale3d( + scale?: number, + originX?: number, + originY?: number, + originZ?: number + ): DOMMatrix; + scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix; + skewX(sx?: number): DOMMatrix; + skewY(sy?: number): DOMMatrix; + toFloat32Array(): Float32Array; + toFloat64Array(): Float64Array; + toJSON(): Object; + transformPoint(point?: DOMPointInit): DOMPoint; + translate(tx?: number, ty?: number, tz?: number): DOMMatrix; + toString(): string; +} + +declare class DOMPoint extends DOMPointReadOnly { + w: number; + x: number; + y: number; + z: number; + + static fromPoint(other?: DOMPointInit): DOMPoint; + + constructor(x?: number, y?: number, z?: number, w?: number): void; +} + +declare class DOMPointReadOnly { + +w: number; + +x: number; + +y: number; + +z: number; + + static fromPoint(other?: DOMPointInit): DOMPointReadOnly; + + constructor(x?: number, y?: number, z?: number, w?: number): void; + matrixTransform(matrix?: DOMMatrixInit): DOMPoint; + toJSON(): Object; +} + +declare class DOMQuad { + +p1: DOMPoint; + +p2: DOMPoint; + +p3: DOMPoint; + +p4: DOMPoint; + + static fromQuad(other?: DOMQuadInit): DOMQuad; + static fromRect(other?: DOMRectInit): DOMQuad; + + constructor( + p1?: DOMPointInit, + p2?: DOMPointInit, + p3?: DOMPointInit, + p4?: DOMPointInit + ): void; + getBounds(): DOMRect; + toJSON(): Object; +} + +declare class DOMRect extends DOMRectReadOnly { + height: number; + width: number; + x: number; + y: number; + + constructor(x?: number, y?: number, width?: number, height?: number): void; + + static fromRect(other?: DOMRectInit): DOMRect; +} + +declare class DOMRectList { + +length: number; + + @@iterator(): Iterator; + + item(index: number): DOMRect; + [index: number]: DOMRect; +} + +declare class DOMRectReadOnly { + +bottom: number; + +height: number; + +left: number; + +right: number; + +top: number; + +width: number; + +x: number; + +y: number; + + constructor(x?: number, y?: number, width?: number, height?: number): void; + + static fromRect(other?: DOMRectInit): DOMRectReadOnly; + toJSON(): Object; +} diff --git a/flow-typed/environments/html.js b/flow-typed/environments/html.js new file mode 100644 index 0000000000000..54e1e48f7396f --- /dev/null +++ b/flow-typed/environments/html.js @@ -0,0 +1,1710 @@ +// flow-typed signature: 760aeea3b9b767e808097fe22b68a20f +// flow-typed version: 8584579196/html/flow_>=v0.261.x + +/* DataTransfer */ + +declare class DataTransfer { + clearData(format?: string): void; + getData(format: string): string; + setData(format: string, data: string): void; + setDragImage(image: Element, x: number, y: number): void; + dropEffect: string; + effectAllowed: string; + files: FileList; // readonly + items: DataTransferItemList; // readonly + types: Array; // readonly +} + +declare class DataTransferItemList { + @@iterator(): Iterator; + length: number; // readonly + [index: number]: DataTransferItem; + add(data: string, type: string): ?DataTransferItem; + add(data: File): ?DataTransferItem; + remove(index: number): void; + clear(): void; +} + +// https://wicg.github.io/file-system-access/#drag-and-drop +declare class DataTransferItem { + kind: string; // readonly + type: string; // readonly + getAsString(_callback: ?(data: string) => mixed): void; + getAsFile(): ?File; + /* + * This is not supported by all browsers, please have a fallback plan for it. + * For more information, please checkout + * https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/webkitGetAsEntry + */ + webkitGetAsEntry(): void | (() => any); + /* + * Not supported in all browsers + * For up to date compatibility information, please visit + * https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsFileSystemHandle + */ + getAsFileSystemHandle?: () => Promise; +} + +declare type DOMStringMap = {[key: string]: string, ...}; + +declare class DOMStringList { + @@iterator(): Iterator; + +[key: number]: string; + +length: number; + item(number): string | null; + contains(string): boolean; +} + +declare type ElementDefinitionOptions = {|extends?: string|}; + +declare interface CustomElementRegistry { + define( + name: string, + ctor: Class, + options?: ElementDefinitionOptions + ): void; + get(name: string): any; + whenDefined(name: string): Promise; +} + +// https://www.w3.org/TR/eventsource/ +declare class EventSource extends EventTarget { + constructor( + url: string, + configuration?: {withCredentials: boolean, ...} + ): void; + +CLOSED: 2; + +CONNECTING: 0; + +OPEN: 1; + +readyState: 0 | 1 | 2; + +url: string; + +withCredentials: boolean; + onerror: () => void; + onmessage: MessageEventListener; + onopen: () => void; + close: () => void; +} + +// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface +declare class ErrorEvent extends Event { + constructor( + type: string, + eventInitDict?: { + ...Event$Init, + message?: string, + filename?: string, + lineno?: number, + colno?: number, + error?: any, + ... + } + ): void; + +message: string; + +filename: string; + +lineno: number; + +colno: number; + +error: any; +} + +// https://html.spec.whatwg.org/multipage/web-messaging.html#broadcasting-to-other-browsing-contexts +declare class BroadcastChannel extends EventTarget { + name: string; + onmessage: ?(event: MessageEvent) => void; + onmessageerror: ?(event: MessageEvent) => void; + + constructor(name: string): void; + postMessage(msg: mixed): void; + close(): void; +} + +// https://www.w3.org/TR/webstorage/#the-storageevent-interface +declare class StorageEvent extends Event { + key: ?string; + oldValue: ?string; + newValue: ?string; + url: string; + storageArea: ?Storage; +} + +// https://www.w3.org/TR/html50/browsers.html#beforeunloadevent +declare class BeforeUnloadEvent extends Event { + returnValue: string; +} + +type ToggleEvent$Init = { + ...Event$Init, + oldState: string, + newState: string, + ... +}; + +declare class ToggleEvent extends Event { + constructor(type: ToggleEventTypes, eventInit?: ToggleEvent$Init): void; + +oldState: string; + +newState: string; +} + +// TODO: HTMLDocument +type FocusOptions = {preventScroll?: boolean, ...}; + +declare class HTMLElement extends Element { + blur(): void; + click(): void; + focus(options?: FocusOptions): void; + getBoundingClientRect(): DOMRect; + forceSpellcheck(): void; + + showPopover(options?: {|source?: HTMLElement|}): void; + hidePopover(): void; + togglePopover( + options?: boolean | {|force?: boolean, source?: HTMLElement|} + ): boolean; + + accessKey: string; + accessKeyLabel: string; + contentEditable: string; + contextMenu: ?HTMLMenuElement; + dataset: DOMStringMap; + dir: 'ltr' | 'rtl' | 'auto'; + draggable: boolean; + dropzone: any; + hidden: boolean; + inert: boolean; + isContentEditable: boolean; + itemProp: any; + itemScope: boolean; + itemType: any; + itemValue: Object; + lang: string; + offsetHeight: number; + offsetLeft: number; + offsetParent: ?Element; + offsetTop: number; + offsetWidth: number; + onabort: ?Function; + onblur: ?Function; + oncancel: ?Function; + oncanplay: ?Function; + oncanplaythrough: ?Function; + onchange: ?Function; + onclick: ?Function; + oncontextmenu: ?Function; + oncuechange: ?Function; + ondblclick: ?Function; + ondurationchange: ?Function; + onemptied: ?Function; + onended: ?Function; + onerror: ?Function; + onfocus: ?Function; + onfullscreenchange: ?Function; + onfullscreenerror: ?Function; + ongotpointercapture: ?Function; + oninput: ?Function; + oninvalid: ?Function; + onkeydown: ?Function; + onkeypress: ?Function; + onkeyup: ?Function; + onload: ?Function; + onloadeddata: ?Function; + onloadedmetadata: ?Function; + onloadstart: ?Function; + onlostpointercapture: ?Function; + onmousedown: ?Function; + onmouseenter: ?Function; + onmouseleave: ?Function; + onmousemove: ?Function; + onmouseout: ?Function; + onmouseover: ?Function; + onmouseup: ?Function; + onmousewheel: ?Function; + onpause: ?Function; + onplay: ?Function; + onplaying: ?Function; + onpointercancel: ?Function; + onpointerdown: ?Function; + onpointerenter: ?Function; + onpointerleave: ?Function; + onpointermove: ?Function; + onpointerout: ?Function; + onpointerover: ?Function; + onpointerup: ?Function; + onprogress: ?Function; + onratechange: ?Function; + onreadystatechange: ?Function; + onreset: ?Function; + onresize: ?Function; + onscroll: ?Function; + onseeked: ?Function; + onseeking: ?Function; + onselect: ?Function; + onshow: ?Function; + onstalled: ?Function; + onsubmit: ?Function; + onsuspend: ?Function; + ontimeupdate: ?Function; + ontoggle: ?Function; + onbeforetoggle: ?Function; + onvolumechange: ?Function; + onwaiting: ?Function; + properties: any; + spellcheck: boolean; + style: CSSStyleDeclaration; + tabIndex: number; + title: string; + translate: boolean; + popover: '' | 'auto' | 'manual' | 'hint'; + + +popoverVisibilityState: 'hidden' | 'showing'; + + +popoverInvoker: HTMLElement | null; +} + +declare class HTMLSlotElement extends HTMLElement { + name: string; + assignedNodes(options?: {flatten: boolean, ...}): Node[]; +} + +declare class HTMLTableElement extends HTMLElement { + tagName: 'TABLE'; + caption: HTMLTableCaptionElement | null; + tHead: HTMLTableSectionElement | null; + tFoot: HTMLTableSectionElement | null; + +tBodies: HTMLCollection; + +rows: HTMLCollection; + createTHead(): HTMLTableSectionElement; + deleteTHead(): void; + createTFoot(): HTMLTableSectionElement; + deleteTFoot(): void; + createCaption(): HTMLTableCaptionElement; + deleteCaption(): void; + insertRow(index?: number): HTMLTableRowElement; + deleteRow(index: number): void; +} + +declare class HTMLTableCaptionElement extends HTMLElement { + tagName: 'CAPTION'; +} + +declare class HTMLTableColElement extends HTMLElement { + tagName: 'COL' | 'COLGROUP'; + span: number; +} + +declare class HTMLTableSectionElement extends HTMLElement { + tagName: 'THEAD' | 'TFOOT' | 'TBODY'; + +rows: HTMLCollection; + insertRow(index?: number): HTMLTableRowElement; + deleteRow(index: number): void; +} + +declare class HTMLTableCellElement extends HTMLElement { + tagName: 'TD' | 'TH'; + colSpan: number; + rowSpan: number; + +cellIndex: number; +} + +declare class HTMLTableRowElement extends HTMLElement { + tagName: 'TR'; + align: 'left' | 'right' | 'center'; + +rowIndex: number; + +sectionRowIndex: number; + +cells: HTMLCollection; + deleteCell(index: number): void; + insertCell(index?: number): HTMLTableCellElement; +} + +declare class HTMLMenuElement extends HTMLElement { + getCompact(): boolean; + setCompact(compact: boolean): void; +} + +declare class HTMLBaseElement extends HTMLElement { + href: string; + target: string; +} + +declare class HTMLTemplateElement extends HTMLElement { + content: DocumentFragment; +} + +declare class CanvasGradient { + addColorStop(offset: number, color: string): void; +} + +declare class CanvasPattern { + setTransform(matrix: SVGMatrix): void; +} + +declare class ImageBitmap { + close(): void; + width: number; + height: number; +} + +type CanvasFillRule = string; + +type CanvasImageSource = + | HTMLImageElement + | HTMLVideoElement + | HTMLCanvasElement + | CanvasRenderingContext2D + | ImageBitmap; + +declare class TextMetrics { + // x-direction + width: number; + actualBoundingBoxLeft: number; + actualBoundingBoxRight: number; + + // y-direction + fontBoundingBoxAscent: number; + fontBoundingBoxDescent: number; + actualBoundingBoxAscent: number; + actualBoundingBoxDescent: number; + emHeightAscent: number; + emHeightDescent: number; + hangingBaseline: number; + alphabeticBaseline: number; + ideographicBaseline: number; +} + +declare class CanvasDrawingStyles { + width: number; + actualBoundingBoxLeft: number; + actualBoundingBoxRight: number; + + // y-direction + fontBoundingBoxAscent: number; + fontBoundingBoxDescent: number; + actualBoundingBoxAscent: number; + actualBoundingBoxDescent: number; + emHeightAscent: number; + emHeightDescent: number; + hangingBaseline: number; + alphabeticBaseline: number; + ideographicBaseline: number; +} + +declare class Path2D { + constructor(path?: Path2D | string): void; + + addPath(path: Path2D, transformation?: ?SVGMatrix): void; + addPathByStrokingPath( + path: Path2D, + styles: CanvasDrawingStyles, + transformation?: ?SVGMatrix + ): void; + addText( + text: string, + styles: CanvasDrawingStyles, + transformation: ?SVGMatrix, + x: number, + y: number, + maxWidth?: number + ): void; + addPathByStrokingText( + text: string, + styles: CanvasDrawingStyles, + transformation: ?SVGMatrix, + x: number, + y: number, + maxWidth?: number + ): void; + addText( + text: string, + styles: CanvasDrawingStyles, + transformation: ?SVGMatrix, + path: Path2D, + maxWidth?: number + ): void; + addPathByStrokingText( + text: string, + styles: CanvasDrawingStyles, + transformation: ?SVGMatrix, + path: Path2D, + maxWidth?: number + ): void; + + // CanvasPathMethods + // shared path API methods + arc( + x: number, + y: number, + radius: number, + startAngle: number, + endAngle: number, + anticlockwise?: boolean + ): void; + arcTo( + x1: number, + y1: number, + x2: number, + y2: number, + radius: number, + _: void, + _: void + ): void; + arcTo( + x1: number, + y1: number, + x2: number, + y2: number, + radiusX: number, + radiusY: number, + rotation: number + ): void; + bezierCurveTo( + cp1x: number, + cp1y: number, + cp2x: number, + cp2y: number, + x: number, + y: number + ): void; + closePath(): void; + ellipse( + x: number, + y: number, + radiusX: number, + radiusY: number, + rotation: number, + startAngle: number, + endAngle: number, + anticlockwise?: boolean + ): void; + lineTo(x: number, y: number): void; + moveTo(x: number, y: number): void; + quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void; + rect(x: number, y: number, w: number, h: number): void; +} + +declare class ImageData { + width: number; + height: number; + data: Uint8ClampedArray; + + // constructor methods are used in Worker where CanvasRenderingContext2D + // is unavailable. + // https://html.spec.whatwg.org/multipage/scripting.html#dom-imagedata + constructor(data: Uint8ClampedArray, width: number, height: number): void; + constructor(width: number, height: number): void; +} + +declare class CanvasRenderingContext2D { + canvas: HTMLCanvasElement; + + // canvas dimensions + width: number; + height: number; + + // for contexts that aren't directly fixed to a specific canvas + commit(): void; + + // state + save(): void; + restore(): void; + + // transformations + currentTransform: SVGMatrix; + scale(x: number, y: number): void; + rotate(angle: number): void; + translate(x: number, y: number): void; + transform( + a: number, + b: number, + c: number, + d: number, + e: number, + f: number + ): void; + setTransform( + a: number, + b: number, + c: number, + d: number, + e: number, + f: number + ): void; + resetTransform(): void; + + // compositing + globalAlpha: number; + globalCompositeOperation: string; + + // image smoothing + imageSmoothingEnabled: boolean; + imageSmoothingQuality: 'low' | 'medium' | 'high'; + + // filters + filter: string; + + // colours and styles + strokeStyle: string | CanvasGradient | CanvasPattern; + fillStyle: string | CanvasGradient | CanvasPattern; + createLinearGradient( + x0: number, + y0: number, + x1: number, + y1: number + ): CanvasGradient; + createRadialGradient( + x0: number, + y0: number, + r0: number, + x1: number, + y1: number, + r1: number + ): CanvasGradient; + createPattern(image: CanvasImageSource, repetition: ?string): CanvasPattern; + + // shadows + shadowOffsetX: number; + shadowOffsetY: number; + shadowBlur: number; + shadowColor: string; + + // rects + clearRect(x: number, y: number, w: number, h: number): void; + fillRect(x: number, y: number, w: number, h: number): void; + roundRect( + x: number, + y: number, + w: number, + h: number, + radii?: number | DOMPointInit | $ReadOnlyArray + ): void; + strokeRect(x: number, y: number, w: number, h: number): void; + + // path API + beginPath(): void; + fill(fillRule?: CanvasFillRule): void; + fill(path: Path2D, fillRule?: CanvasFillRule): void; + stroke(): void; + stroke(path: Path2D): void; + drawFocusIfNeeded(element: Element): void; + drawFocusIfNeeded(path: Path2D, element: Element): void; + scrollPathIntoView(): void; + scrollPathIntoView(path: Path2D): void; + clip(fillRule?: CanvasFillRule): void; + clip(path: Path2D, fillRule?: CanvasFillRule): void; + resetClip(): void; + isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean; + isPointInPath( + path: Path2D, + x: number, + y: number, + fillRule?: CanvasFillRule + ): boolean; + isPointInStroke(x: number, y: number): boolean; + isPointInStroke(path: Path2D, x: number, y: number): boolean; + + // text (see also the CanvasDrawingStyles interface) + fillText(text: string, x: number, y: number, maxWidth?: number): void; + strokeText(text: string, x: number, y: number, maxWidth?: number): void; + measureText(text: string): TextMetrics; + + // drawing images + drawImage(image: CanvasImageSource, dx: number, dy: number): void; + drawImage( + image: CanvasImageSource, + dx: number, + dy: number, + dw: number, + dh: number + ): void; + drawImage( + image: CanvasImageSource, + sx: number, + sy: number, + sw: number, + sh: number, + dx: number, + dy: number, + dw: number, + dh: number + ): void; + + // hit regions + addHitRegion(options?: HitRegionOptions): void; + removeHitRegion(id: string): void; + clearHitRegions(): void; + + // pixel manipulation + createImageData(sw: number, sh: number): ImageData; + createImageData(imagedata: ImageData): ImageData; + getImageData(sx: number, sy: number, sw: number, sh: number): ImageData; + putImageData(imagedata: ImageData, dx: number, dy: number): void; + putImageData( + imagedata: ImageData, + dx: number, + dy: number, + dirtyX: number, + dirtyY: number, + dirtyWidth: number, + dirtyHeight: number + ): void; + + // CanvasDrawingStyles + // line caps/joins + lineWidth: number; + lineCap: string; + lineJoin: string; + miterLimit: number; + + // dashed lines + setLineDash(segments: Array): void; + getLineDash(): Array; + lineDashOffset: number; + + // text + font: string; + textAlign: string; + textBaseline: string; + direction: string; + + // CanvasPathMethods + // shared path API methods + closePath(): void; + moveTo(x: number, y: number): void; + lineTo(x: number, y: number): void; + quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void; + bezierCurveTo( + cp1x: number, + cp1y: number, + cp2x: number, + cp2y: number, + x: number, + y: number + ): void; + arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void; + arcTo( + x1: number, + y1: number, + x2: number, + y2: number, + radiusX: number, + radiusY: number, + rotation: number + ): void; + rect(x: number, y: number, w: number, h: number): void; + arc( + x: number, + y: number, + radius: number, + startAngle: number, + endAngle: number, + anticlockwise?: boolean + ): void; + ellipse( + x: number, + y: number, + radiusX: number, + radiusY: number, + rotation: number, + startAngle: number, + endAngle: number, + anticlockwise?: boolean + ): void; +} + +// http://www.w3.org/TR/html5/scripting-1.html#renderingcontext +type RenderingContext = CanvasRenderingContext2D | WebGLRenderingContext; + +// https://www.w3.org/TR/html5/scripting-1.html#htmlcanvaselement +declare class HTMLCanvasElement extends HTMLElement { + tagName: 'CANVAS'; + width: number; + height: number; + getContext(contextId: '2d', ...args: any): CanvasRenderingContext2D; + getContext( + contextId: 'webgl', + contextAttributes?: Partial + ): ?WebGLRenderingContext; + // IE currently only supports "experimental-webgl" + getContext( + contextId: 'experimental-webgl', + contextAttributes?: Partial + ): ?WebGLRenderingContext; + getContext(contextId: string, ...args: any): ?RenderingContext; // fallback + toDataURL(type?: string, ...args: any): string; + toBlob(callback: (v: File) => void, type?: string, ...args: any): void; + captureStream(frameRate?: number): CanvasCaptureMediaStream; +} + +// https://html.spec.whatwg.org/multipage/forms.html#the-details-element +declare class HTMLDetailsElement extends HTMLElement { + tagName: 'DETAILS'; + open: boolean; +} + +declare class HTMLFormElement extends HTMLElement { + tagName: 'FORM'; + @@iterator(): Iterator; + [index: number | string]: HTMLElement | null; + acceptCharset: string; + action: string; + elements: HTMLCollection; + encoding: string; + enctype: string; + length: number; + method: string; + name: string; + rel: string; + target: string; + + checkValidity(): boolean; + reportValidity(): boolean; + reset(): void; + submit(): void; +} + +// https://www.w3.org/TR/html5/forms.html#the-fieldset-element +declare class HTMLFieldSetElement extends HTMLElement { + tagName: 'FIELDSET'; + disabled: boolean; + elements: HTMLCollection; // readonly + form: HTMLFormElement | null; // readonly + name: string; + type: string; // readonly + + checkValidity(): boolean; + setCustomValidity(error: string): void; +} + +declare class HTMLLegendElement extends HTMLElement { + tagName: 'LEGEND'; + form: HTMLFormElement | null; // readonly +} + +declare class HTMLIFrameElement extends HTMLElement { + tagName: 'IFRAME'; + allowFullScreen: boolean; + contentDocument: Document; + contentWindow: any; + frameBorder: string; + height: string; + marginHeight: string; + marginWidth: string; + name: string; + scrolling: string; + sandbox: DOMTokenList; + src: string; + // flowlint unsafe-getters-setters:off + get srcdoc(): string; + set srcdoc(value: string | TrustedHTML): void; + // flowlint unsafe-getters-setters:error + width: string; +} + +declare class HTMLImageElement extends HTMLElement { + tagName: 'IMG'; + alt: string; + complete: boolean; // readonly + crossOrigin: ?string; + currentSrc: string; // readonly + height: number; + decode(): Promise; + isMap: boolean; + naturalHeight: number; // readonly + naturalWidth: number; // readonly + sizes: string; + src: string; + srcset: string; + useMap: string; + width: number; +} + +declare class Image extends HTMLImageElement { + constructor(width?: number, height?: number): void; +} + +declare class MediaError { + MEDIA_ERR_ABORTED: number; + MEDIA_ERR_NETWORK: number; + MEDIA_ERR_DECODE: number; + MEDIA_ERR_SRC_NOT_SUPPORTED: number; + code: number; + message: ?string; +} + +declare class TimeRanges { + length: number; + start(index: number): number; + end(index: number): number; +} + +declare class Audio extends HTMLAudioElement { + constructor(URLString?: string): void; +} + +declare class AudioTrack { + id: string; + kind: string; + label: string; + language: string; + enabled: boolean; +} + +declare class AudioTrackList extends EventTarget { + length: number; + [index: number]: AudioTrack; + + getTrackById(id: string): ?AudioTrack; + + onchange: (ev: any) => any; + onaddtrack: (ev: any) => any; + onremovetrack: (ev: any) => any; +} + +declare class VideoTrack { + id: string; + kind: string; + label: string; + language: string; + selected: boolean; +} + +declare class VideoTrackList extends EventTarget { + length: number; + [index: number]: VideoTrack; + getTrackById(id: string): ?VideoTrack; + selectedIndex: number; + + onchange: (ev: any) => any; + onaddtrack: (ev: any) => any; + onremovetrack: (ev: any) => any; +} + +declare class TextTrackCue extends EventTarget { + constructor(startTime: number, endTime: number, text: string): void; + + track: TextTrack; + id: string; + startTime: number; + endTime: number; + pauseOnExit: boolean; + vertical: string; + snapToLines: boolean; + lines: number; + position: number; + size: number; + align: string; + text: string; + + getCueAsHTML(): Node; + onenter: (ev: any) => any; + onexit: (ev: any) => any; +} + +declare class TextTrackCueList { + @@iterator(): Iterator; + length: number; + [index: number]: TextTrackCue; + getCueById(id: string): ?TextTrackCue; +} + +declare class TextTrack extends EventTarget { + kind: string; + label: string; + language: string; + + mode: string; + + cues: TextTrackCueList; + activeCues: TextTrackCueList; + + addCue(cue: TextTrackCue): void; + removeCue(cue: TextTrackCue): void; + + oncuechange: (ev: any) => any; +} + +declare class TextTrackList extends EventTarget { + length: number; + [index: number]: TextTrack; + + onaddtrack: (ev: any) => any; + onremovetrack: (ev: any) => any; +} + +declare class HTMLMediaElement extends HTMLElement { + // error state + error: ?MediaError; + + // network state + src: string; + srcObject: ?any; + currentSrc: string; + crossOrigin: ?string; + NETWORK_EMPTY: number; + NETWORK_IDLE: number; + NETWORK_LOADING: number; + NETWORK_NO_SOURCE: number; + networkState: number; + preload: string; + buffered: TimeRanges; + load(): void; + canPlayType(type: string): string; + + // ready state + HAVE_NOTHING: number; + HAVE_METADATA: number; + HAVE_CURRENT_DATA: number; + HAVE_FUTURE_DATA: number; + HAVE_ENOUGH_DATA: number; + readyState: number; + seeking: boolean; + + // playback state + currentTime: number; + duration: number; + startDate: Date; + paused: boolean; + defaultPlaybackRate: number; + playbackRate: number; + played: TimeRanges; + seekable: TimeRanges; + ended: boolean; + autoplay: boolean; + loop: boolean; + play(): Promise; + pause(): void; + fastSeek(): void; + captureStream(): MediaStream; + + // media controller + mediaGroup: string; + controller: ?any; + + // controls + controls: boolean; + volume: number; + muted: boolean; + defaultMuted: boolean; + controlsList?: DOMTokenList; + + // tracks + audioTracks: AudioTrackList; + videoTracks: VideoTrackList; + textTracks: TextTrackList; + addTextTrack(kind: string, label?: string, language?: string): TextTrack; + + // media keys + mediaKeys?: ?MediaKeys; + setMediakeys?: (mediakeys: ?MediaKeys) => Promise; +} + +declare class HTMLAudioElement extends HTMLMediaElement { + tagName: 'AUDIO'; +} + +declare class HTMLVideoElement extends HTMLMediaElement { + tagName: 'VIDEO'; + width: number; + height: number; + videoWidth: number; + videoHeight: number; + poster: string; +} + +declare class HTMLSourceElement extends HTMLElement { + tagName: 'SOURCE'; + src: string; + type: string; + + //when used with the picture element + srcset: string; + sizes: string; + media: string; +} + +declare class ValidityState { + badInput: boolean; + customError: boolean; + patternMismatch: boolean; + rangeOverflow: boolean; + rangeUnderflow: boolean; + stepMismatch: boolean; + tooLong: boolean; + tooShort: boolean; + typeMismatch: boolean; + valueMissing: boolean; + valid: boolean; +} + +// https://w3c.github.io/html/sec-forms.html#dom-selectionapielements-setselectionrange +type SelectionDirection = 'backward' | 'forward' | 'none'; +type SelectionMode = 'select' | 'start' | 'end' | 'preserve'; +declare class HTMLInputElement extends HTMLElement { + tagName: 'INPUT'; + accept: string; + align: string; + alt: string; + autocomplete: string; + autofocus: boolean; + border: string; + checked: boolean; + complete: boolean; + defaultChecked: boolean; + defaultValue: string; + dirname: string; + disabled: boolean; + dynsrc: string; + files: FileList; + form: HTMLFormElement | null; + formAction: string; + formEncType: string; + formMethod: string; + formNoValidate: boolean; + formTarget: string; + height: string; + hspace: number; + indeterminate: boolean; + labels: NodeList; + list: HTMLElement | null; + loop: number; + lowsrc: string; + max: string; + maxLength: number; + min: string; + multiple: boolean; + name: string; + pattern: string; + placeholder: string; + readOnly: boolean; + required: boolean; + selectionDirection: SelectionDirection; + selectionEnd: number; + selectionStart: number; + size: number; + src: string; + start: string; + status: boolean; + step: string; + type: string; + useMap: string; + validationMessage: string; + validity: ValidityState; + value: string; + valueAsDate: Date; + valueAsNumber: number; + vrml: string; + vspace: number; + width: string; + willValidate: boolean; + popoverTargetElement: Element | null; + popoverTargetAction: 'toggle' | 'show' | 'hide'; + + checkValidity(): boolean; + reportValidity(): boolean; + setCustomValidity(error: string): void; + createTextRange(): TextRange; + select(): void; + setRangeText( + replacement: string, + start?: void, + end?: void, + selectMode?: void + ): void; + setRangeText( + replacement: string, + start: number, + end: number, + selectMode?: SelectionMode + ): void; + setSelectionRange( + start: number, + end: number, + direction?: SelectionDirection + ): void; + showPicker(): void; + stepDown(stepDecrement?: number): void; + stepUp(stepIncrement?: number): void; +} + +declare class HTMLButtonElement extends HTMLElement { + tagName: 'BUTTON'; + autofocus: boolean; + disabled: boolean; + form: HTMLFormElement | null; + labels: NodeList | null; + name: string; + type: string; + validationMessage: string; + validity: ValidityState; + value: string; + willValidate: boolean; + + checkValidity(): boolean; + reportValidity(): boolean; + setCustomValidity(error: string): void; + popoverTargetElement: Element | null; + popoverTargetAction: 'toggle' | 'show' | 'hide'; +} + +// https://w3c.github.io/html/sec-forms.html#the-textarea-element +declare class HTMLTextAreaElement extends HTMLElement { + tagName: 'TEXTAREA'; + autofocus: boolean; + cols: number; + dirName: string; + disabled: boolean; + form: HTMLFormElement | null; + maxLength: number; + name: string; + placeholder: string; + readOnly: boolean; + required: boolean; + rows: number; + wrap: string; + + type: string; + defaultValue: string; + value: string; + textLength: number; + + willValidate: boolean; + validity: ValidityState; + validationMessage: string; + checkValidity(): boolean; + setCustomValidity(error: string): void; + + labels: NodeList; + + select(): void; + selectionStart: number; + selectionEnd: number; + selectionDirection: SelectionDirection; + setSelectionRange( + start: number, + end: number, + direction?: SelectionDirection + ): void; +} + +declare class HTMLSelectElement extends HTMLElement { + tagName: 'SELECT'; + autocomplete: string; + autofocus: boolean; + disabled: boolean; + form: HTMLFormElement | null; + labels: NodeList; + length: number; + multiple: boolean; + name: string; + options: HTMLOptionsCollection; + required: boolean; + selectedIndex: number; + selectedOptions: HTMLCollection; + size: number; + type: string; + validationMessage: string; + validity: ValidityState; + value: string; + willValidate: boolean; + + add(element: HTMLElement, before?: HTMLElement): void; + checkValidity(): boolean; + item(index: number): HTMLOptionElement | null; + namedItem(name: string): HTMLOptionElement | null; + remove(index?: number): void; + setCustomValidity(error: string): void; +} + +declare class HTMLOptionsCollection extends HTMLCollection { + selectedIndex: number; + add( + element: HTMLOptionElement | HTMLOptGroupElement, + before?: HTMLElement | number + ): void; + remove(index: number): void; +} + +declare class HTMLOptionElement extends HTMLElement { + tagName: 'OPTION'; + defaultSelected: boolean; + disabled: boolean; + form: HTMLFormElement | null; + index: number; + label: string; + selected: boolean; + text: string; + value: string; +} + +declare class HTMLOptGroupElement extends HTMLElement { + tagName: 'OPTGROUP'; + disabled: boolean; + label: string; +} + +declare class HTMLAnchorElement extends HTMLElement { + tagName: 'A'; + charset: string; + coords: string; + download: string; + hash: string; + host: string; + hostname: string; + href: string; + hreflang: string; + media: string; + name: string; + origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + rel: string; + rev: string; + search: string; + shape: string; + target: string; + text: string; + type: string; + username: string; +} + +// https://w3c.github.io/html/sec-forms.html#the-label-element +declare class HTMLLabelElement extends HTMLElement { + tagName: 'LABEL'; + form: HTMLFormElement | null; + htmlFor: string; + control: HTMLElement | null; +} + +declare class HTMLLinkElement extends HTMLElement { + tagName: 'LINK'; + crossOrigin: ?('anonymous' | 'use-credentials'); + href: string; + hreflang: string; + media: string; + rel: string; + sizes: DOMTokenList; + type: string; + as: string; +} + +declare class HTMLScriptElement extends HTMLElement { + tagName: 'SCRIPT'; + async: boolean; + charset: string; + crossOrigin?: string; + defer: boolean; + // flowlint unsafe-getters-setters:off + get src(): string; + set src(value: string | TrustedScriptURL): void; + get text(): string; + set text(value: string | TrustedScript): void; + // flowlint unsafe-getters-setters:error + type: string; +} + +declare class HTMLStyleElement extends HTMLElement { + tagName: 'STYLE'; + disabled: boolean; + media: string; + scoped: boolean; + sheet: ?CSSStyleSheet; + type: string; +} + +declare class HTMLParagraphElement extends HTMLElement { + tagName: 'P'; + align: 'left' | 'center' | 'right' | 'justify'; // deprecated in HTML 4.01 +} + +declare class HTMLHtmlElement extends HTMLElement { + tagName: 'HTML'; +} + +declare class HTMLBodyElement extends HTMLElement { + tagName: 'BODY'; +} + +declare class HTMLHeadElement extends HTMLElement { + tagName: 'HEAD'; +} + +declare class HTMLDivElement extends HTMLElement { + tagName: 'DIV'; +} + +declare class HTMLSpanElement extends HTMLElement { + tagName: 'SPAN'; +} + +declare class HTMLAppletElement extends HTMLElement {} + +declare class HTMLHeadingElement extends HTMLElement { + tagName: 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6'; +} + +declare class HTMLHRElement extends HTMLElement { + tagName: 'HR'; +} + +declare class HTMLBRElement extends HTMLElement { + tagName: 'BR'; +} + +declare class HTMLDListElement extends HTMLElement { + tagName: 'DL'; +} + +declare class HTMLAreaElement extends HTMLElement { + tagName: 'AREA'; + alt: string; + coords: string; + shape: string; + target: string; + download: string; + ping: string; + rel: string; + relList: DOMTokenList; + referrerPolicy: string; +} + +declare class HTMLDataElement extends HTMLElement { + tagName: 'DATA'; + value: string; +} + +declare class HTMLDataListElement extends HTMLElement { + tagName: 'DATALIST'; + options: HTMLCollection; +} + +declare class HTMLDialogElement extends HTMLElement { + tagName: 'DIALOG'; + open: boolean; + returnValue: string; + show(): void; + showModal(): void; + close(returnValue: ?string): void; +} + +declare class HTMLEmbedElement extends HTMLElement { + tagName: 'EMBED'; + src: string; + type: string; + width: string; + height: string; + getSVGDocument(): ?Document; +} + +declare class HTMLMapElement extends HTMLElement { + tagName: 'MAP'; + areas: HTMLCollection; + images: HTMLCollection; + name: string; +} + +declare class HTMLMeterElement extends HTMLElement { + tagName: 'METER'; + high: number; + low: number; + max: number; + min: number; + optimum: number; + value: number; + labels: NodeList; +} + +declare class HTMLModElement extends HTMLElement { + tagName: 'DEL' | 'INS'; + cite: string; + dateTime: string; +} + +declare class HTMLObjectElement extends HTMLElement { + tagName: 'OBJECT'; + contentDocument: ?Document; + contentWindow: ?WindowProxy; + data: string; + form: ?HTMLFormElement; + height: string; + name: string; + type: string; + typeMustMatch: boolean; + useMap: string; + validationMessage: string; + validity: ValidityState; + width: string; + willValidate: boolean; + checkValidity(): boolean; + getSVGDocument(): ?Document; + reportValidity(): boolean; + setCustomValidity(error: string): void; +} + +declare class HTMLOutputElement extends HTMLElement { + defaultValue: string; + form: ?HTMLFormElement; + htmlFor: DOMTokenList; + labels: NodeList; + name: string; + type: string; + validationMessage: string; + validity: ValidityState; + value: string; + willValidate: boolean; + checkValidity(): boolean; + reportValidity(): boolean; + setCustomValidity(error: string): void; +} + +declare class HTMLParamElement extends HTMLElement { + tagName: 'PARAM'; + name: string; + value: string; +} + +declare class HTMLProgressElement extends HTMLElement { + tagName: 'PROGRESS'; + labels: NodeList; + max: number; + position: number; + value: number; +} + +declare class HTMLPictureElement extends HTMLElement { + tagName: 'PICTURE'; +} + +declare class HTMLTimeElement extends HTMLElement { + tagName: 'TIME'; + dateTime: string; +} + +declare class HTMLTitleElement extends HTMLElement { + tagName: 'TITLE'; + text: string; +} + +declare class HTMLTrackElement extends HTMLElement { + tagName: 'TRACK'; + static NONE: 0; + static LOADING: 1; + static LOADED: 2; + static ERROR: 3; + + default: boolean; + kind: string; + label: string; + readyState: 0 | 1 | 2 | 3; + src: string; + srclang: string; + track: TextTrack; +} + +declare class HTMLQuoteElement extends HTMLElement { + tagName: 'BLOCKQUOTE' | 'Q'; + cite: string; +} + +declare class HTMLOListElement extends HTMLElement { + tagName: 'OL'; + reversed: boolean; + start: number; + type: string; +} + +declare class HTMLUListElement extends HTMLElement { + tagName: 'UL'; +} + +declare class HTMLLIElement extends HTMLElement { + tagName: 'LI'; + value: number; +} + +declare class HTMLPreElement extends HTMLElement { + tagName: 'PRE'; +} + +declare class HTMLMetaElement extends HTMLElement { + tagName: 'META'; + content: string; + httpEquiv: string; + name: string; +} + +declare class HTMLUnknownElement extends HTMLElement {} + +declare class Storage { + length: number; + getItem(key: string): ?string; + setItem(key: string, data: string): void; + clear(): void; + removeItem(key: string): void; + key(index: number): ?string; + [name: string]: ?string; +} + +/* window */ + +declare type WindowProxy = any; +declare function alert(message?: any): void; +declare function prompt(message?: any, value?: any): string; +declare function close(): void; +declare function confirm(message?: string): boolean; +declare function getComputedStyle( + elt: Element, + pseudoElt?: string +): CSSStyleDeclaration; +declare opaque type AnimationFrameID; +declare function requestAnimationFrame( + callback: (timestamp: number) => void +): AnimationFrameID; +declare function cancelAnimationFrame(requestId: AnimationFrameID): void; +declare opaque type IdleCallbackID; +declare function requestIdleCallback( + cb: (deadline: { + didTimeout: boolean, + timeRemaining: () => number, + ... + }) => void, + opts?: {timeout: number, ...} +): IdleCallbackID; +declare function cancelIdleCallback(id: IdleCallbackID): void; +declare var localStorage: Storage; +declare var devicePixelRatio: number; +declare function focus(): void; +declare function onfocus(ev: Event): any; +declare function open( + url?: string, + target?: string, + features?: string, + replace?: boolean +): any; +declare var parent: WindowProxy; +declare function print(): void; +declare var self: any; +declare var sessionStorage: Storage; +declare var top: WindowProxy; +declare function getSelection(): Selection | null; +declare var customElements: CustomElementRegistry; +declare function scroll(x: number, y: number): void; +declare function scroll(options: ScrollToOptions): void; +declare function scrollTo(x: number, y: number): void; +declare function scrollTo(options: ScrollToOptions): void; +declare function scrollBy(x: number, y: number): void; +declare function scrollBy(options: ScrollToOptions): void; + +type HTMLElementTagNameMap = { + a: HTMLAnchorElement, + abbr: HTMLElement, + address: HTMLElement, + area: HTMLAreaElement, + article: HTMLElement, + aside: HTMLElement, + audio: HTMLAudioElement, + b: HTMLElement, + base: HTMLBaseElement, + bdi: HTMLElement, + bdo: HTMLElement, + blockquote: HTMLQuoteElement, + body: HTMLBodyElement, + br: HTMLBRElement, + button: HTMLButtonElement, + canvas: HTMLCanvasElement, + caption: HTMLTableCaptionElement, + cite: HTMLElement, + code: HTMLElement, + col: HTMLTableColElement, + colgroup: HTMLTableColElement, + data: HTMLDataElement, + datalist: HTMLDataListElement, + dd: HTMLElement, + del: HTMLModElement, + details: HTMLDetailsElement, + dfn: HTMLElement, + dialog: HTMLDialogElement, + div: HTMLDivElement, + dl: HTMLDListElement, + dt: HTMLElement, + em: HTMLElement, + embed: HTMLEmbedElement, + fieldset: HTMLFieldSetElement, + figcaption: HTMLElement, + figure: HTMLElement, + footer: HTMLElement, + form: HTMLFormElement, + h1: HTMLHeadingElement, + h2: HTMLHeadingElement, + h3: HTMLHeadingElement, + h4: HTMLHeadingElement, + h5: HTMLHeadingElement, + h6: HTMLHeadingElement, + head: HTMLHeadElement, + header: HTMLElement, + hgroup: HTMLElement, + hr: HTMLHRElement, + html: HTMLHtmlElement, + i: HTMLElement, + iframe: HTMLIFrameElement, + img: HTMLImageElement, + input: HTMLInputElement, + ins: HTMLModElement, + kbd: HTMLElement, + label: HTMLLabelElement, + legend: HTMLLegendElement, + li: HTMLLIElement, + link: HTMLLinkElement, + main: HTMLElement, + map: HTMLMapElement, + mark: HTMLElement, + menu: HTMLMenuElement, + meta: HTMLMetaElement, + meter: HTMLMeterElement, + nav: HTMLElement, + noscript: HTMLElement, + object: HTMLObjectElement, + ol: HTMLOListElement, + optgroup: HTMLOptGroupElement, + option: HTMLOptionElement, + output: HTMLOutputElement, + p: HTMLParagraphElement, + picture: HTMLPictureElement, + pre: HTMLPreElement, + progress: HTMLProgressElement, + q: HTMLQuoteElement, + rp: HTMLElement, + rt: HTMLElement, + ruby: HTMLElement, + s: HTMLElement, + samp: HTMLElement, + script: HTMLScriptElement, + search: HTMLElement, + section: HTMLElement, + select: HTMLSelectElement, + slot: HTMLSlotElement, + small: HTMLElement, + source: HTMLSourceElement, + span: HTMLSpanElement, + strong: HTMLElement, + style: HTMLStyleElement, + sub: HTMLElement, + summary: HTMLElement, + sup: HTMLElement, + table: HTMLTableElement, + tbody: HTMLTableSectionElement, + td: HTMLTableCellElement, + template: HTMLTemplateElement, + textarea: HTMLTextAreaElement, + tfoot: HTMLTableSectionElement, + th: HTMLTableCellElement, + thead: HTMLTableSectionElement, + time: HTMLTimeElement, + title: HTMLTitleElement, + tr: HTMLTableRowElement, + track: HTMLTrackElement, + u: HTMLElement, + ul: HTMLUListElement, + var: HTMLElement, + video: HTMLVideoElement, + wbr: HTMLElement, + [string]: Element, +}; diff --git a/flow-typed/environments/node.js b/flow-typed/environments/node.js new file mode 100644 index 0000000000000..66d20232a3395 --- /dev/null +++ b/flow-typed/environments/node.js @@ -0,0 +1,4282 @@ +// flow-typed signature: 44d8f5b0b708cdf7288ec50b7c08e1bf +// flow-typed version: 832153ff79/node/flow_>=v0.261.x + +interface ErrnoError extends Error { + address?: string; + code?: string; + dest?: string; + errno?: string | number; + info?: Object; + path?: string; + port?: number; + syscall?: string; +} + +type Node$Conditional = T extends true + ? IfTrue + : T extends false + ? IfFalse + : IfTrue | IfFalse; + +type buffer$NonBufferEncoding = + | 'hex' + | 'HEX' + | 'utf8' + | 'UTF8' + | 'utf-8' + | 'UTF-8' + | 'ascii' + | 'ASCII' + | 'binary' + | 'BINARY' + | 'base64' + | 'BASE64' + | 'ucs2' + | 'UCS2' + | 'ucs-2' + | 'UCS-2' + | 'utf16le' + | 'UTF16LE' + | 'utf-16le' + | 'UTF-16LE' + | 'latin1'; +type buffer$Encoding = buffer$NonBufferEncoding | 'buffer'; +type buffer$ToJSONRet = { + type: string, + data: Array, + ... +}; + +declare class Buffer extends Uint8Array { + constructor( + value: Array | number | string | Buffer | ArrayBuffer, + encoding?: buffer$Encoding + ): void; + [i: number]: number; + length: number; + + compare(otherBuffer: Buffer): number; + copy( + targetBuffer: Buffer, + targetStart?: number, + sourceStart?: number, + sourceEnd?: number + ): number; + entries(): Iterator<[number, number]>; + equals(otherBuffer: Buffer): boolean; + fill( + value: string | Buffer | number, + offset?: number, + end?: number, + encoding?: string + ): this; + fill(value: string, encoding?: string): this; + includes( + value: string | Buffer | number, + offsetOrEncoding?: number | buffer$Encoding, + encoding?: buffer$Encoding + ): boolean; + indexOf( + value: string | Buffer | number, + offsetOrEncoding?: number | buffer$Encoding, + encoding?: buffer$Encoding + ): number; + inspect(): string; + keys(): Iterator; + lastIndexOf( + value: string | Buffer | number, + offsetOrEncoding?: number | buffer$Encoding, + encoding?: buffer$Encoding + ): number; + readDoubleBE(offset?: number, noAssert?: boolean): number; + readDoubleLE(offset?: number, noAssert?: boolean): number; + readFloatBE(offset?: number, noAssert?: boolean): number; + readFloatLE(offset?: number, noAssert?: boolean): number; + readInt16BE(offset?: number, noAssert?: boolean): number; + readInt16LE(offset?: number, noAssert?: boolean): number; + readInt32BE(offset?: number, noAssert?: boolean): number; + readInt32LE(offset?: number, noAssert?: boolean): number; + readInt8(offset?: number, noAssert?: boolean): number; + readIntBE(offset: number, byteLength: number, noAssert?: boolean): number; + readIntLE(offset: number, byteLength: number, noAssert?: boolean): number; + readUInt16BE(offset?: number, noAssert?: boolean): number; + readUInt16LE(offset?: number, noAssert?: boolean): number; + readUInt32BE(offset?: number, noAssert?: boolean): number; + readUInt32LE(offset?: number, noAssert?: boolean): number; + readUInt8(offset?: number, noAssert?: boolean): number; + readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number; + readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number; + slice(start?: number, end?: number): this; + swap16(): Buffer; + swap32(): Buffer; + swap64(): Buffer; + toJSON(): buffer$ToJSONRet; + toString(encoding?: buffer$Encoding, start?: number, end?: number): string; + values(): Iterator; + write( + string: string, + offset?: number, + length?: number, + encoding?: buffer$Encoding + ): number; + writeDoubleBE(value: number, offset?: number, noAssert?: boolean): number; + writeDoubleLE(value: number, offset?: number, noAssert?: boolean): number; + writeFloatBE(value: number, offset?: number, noAssert?: boolean): number; + writeFloatLE(value: number, offset?: number, noAssert?: boolean): number; + writeInt16BE(value: number, offset?: number, noAssert?: boolean): number; + writeInt16LE(value: number, offset?: number, noAssert?: boolean): number; + writeInt32BE(value: number, offset?: number, noAssert?: boolean): number; + writeInt32LE(value: number, offset?: number, noAssert?: boolean): number; + writeInt8(value: number, offset?: number, noAssert?: boolean): number; + writeIntBE( + value: number, + offset: number, + byteLength: number, + noAssert?: boolean + ): number; + writeIntLE( + value: number, + offset: number, + byteLength: number, + noAssert?: boolean + ): number; + writeUInt16BE(value: number, offset?: number, noAssert?: boolean): number; + writeUInt16LE(value: number, offset?: number, noAssert?: boolean): number; + writeUInt32BE(value: number, offset?: number, noAssert?: boolean): number; + writeUInt32LE(value: number, offset?: number, noAssert?: boolean): number; + writeUInt8(value: number, offset?: number, noAssert?: boolean): number; + writeUIntBE( + value: number, + offset: number, + byteLength: number, + noAssert?: boolean + ): number; + writeUIntLE( + value: number, + offset: number, + byteLength: number, + noAssert?: boolean + ): number; + + static alloc( + size: number, + fill?: string | number, + encoding?: buffer$Encoding + ): Buffer; + static allocUnsafe(size: number): Buffer; + static allocUnsafeSlow(size: number): Buffer; + static byteLength( + string: string | Buffer | $TypedArray | DataView | ArrayBuffer, + encoding?: buffer$Encoding + ): number; + static compare(buf1: Buffer, buf2: Buffer): number; + static concat(list: Array, totalLength?: number): Buffer; + + static from(value: Buffer): Buffer; + static from(value: string, encoding?: buffer$Encoding): Buffer; + static from( + value: ArrayBuffer | SharedArrayBuffer, + byteOffset?: number, + length?: number + ): Buffer; + static from(value: Iterable): this; + static isBuffer(obj: any): boolean; + static isEncoding(encoding: string): boolean; +} + +declare type Node$Buffer = typeof Buffer; + +declare module 'buffer' { + declare var kMaxLength: number; + declare var INSPECT_MAX_BYTES: number; + declare function transcode( + source: Node$Buffer, + fromEnc: buffer$Encoding, + toEnc: buffer$Encoding + ): Node$Buffer; + declare var Buffer: Node$Buffer; +} + +type child_process$execOpts = { + cwd?: string, + env?: Object, + encoding?: string, + shell?: string, + timeout?: number, + maxBuffer?: number, + killSignal?: string | number, + uid?: number, + gid?: number, + windowsHide?: boolean, + ... +}; + +declare class child_process$Error extends Error { + code: number | string | null; + errno?: string; + syscall?: string; + path?: string; + spawnargs?: Array; + killed?: boolean; + signal?: string | null; + cmd: string; +} + +type child_process$execCallback = ( + error: ?child_process$Error, + stdout: string | Buffer, + stderr: string | Buffer +) => void; + +type child_process$execSyncOpts = { + cwd?: string, + input?: string | Buffer | $TypedArray | DataView, + stdio?: string | Array, + env?: Object, + shell?: string, + uid?: number, + gid?: number, + timeout?: number, + killSignal?: string | number, + maxBuffer?: number, + encoding?: string, + windowsHide?: boolean, + ... +}; + +type child_process$execFileOpts = { + cwd?: string, + env?: Object, + encoding?: string, + timeout?: number, + maxBuffer?: number, + killSignal?: string | number, + uid?: number, + gid?: number, + windowsHide?: boolean, + windowsVerbatimArguments?: boolean, + shell?: boolean | string, + ... +}; + +type child_process$execFileCallback = ( + error: ?child_process$Error, + stdout: string | Buffer, + stderr: string | Buffer +) => void; + +type child_process$execFileSyncOpts = { + cwd?: string, + input?: string | Buffer | $TypedArray | DataView, + stdio?: string | Array, + env?: Object, + uid?: number, + gid?: number, + timeout?: number, + killSignal?: string | number, + maxBuffer?: number, + encoding?: string, + windowsHide?: boolean, + shell?: boolean | string, + ... +}; + +type child_process$forkOpts = { + cwd?: string, + env?: Object, + execPath?: string, + execArgv?: Array, + silent?: boolean, + stdio?: Array | string, + windowsVerbatimArguments?: boolean, + uid?: number, + gid?: number, + ... +}; + +type child_process$Handle = any; // TODO + +type child_process$spawnOpts = { + cwd?: string, + env?: Object, + argv0?: string, + stdio?: string | Array, + detached?: boolean, + uid?: number, + gid?: number, + shell?: boolean | string, + windowsVerbatimArguments?: boolean, + windowsHide?: boolean, + ... +}; + +type child_process$spawnRet = { + pid: number, + output: Array, + stdout: Buffer | string, + stderr: Buffer | string, + status: number, + signal: string, + error: Error, + ... +}; + +type child_process$spawnSyncOpts = { + cwd?: string, + input?: string | Buffer, + stdio?: string | Array, + env?: Object, + uid?: number, + gid?: number, + timeout?: number, + killSignal?: string, + maxBuffer?: number, + encoding?: string, + shell?: boolean | string, + ... +}; + +type child_process$spawnSyncRet = child_process$spawnRet; + +declare class child_process$ChildProcess extends events$EventEmitter { + channel: Object; + connected: boolean; + killed: boolean; + pid: number; + exitCode: number | null; + stderr: stream$Readable; + stdin: stream$Writable; + stdio: Array; + stdout: stream$Readable; + + disconnect(): void; + kill(signal?: string): void; + send( + message: Object, + sendHandleOrCallback?: child_process$Handle, + optionsOrCallback?: Object | Function, + callback?: Function + ): boolean; + unref(): void; + ref(): void; +} + +declare module 'child_process' { + declare var ChildProcess: typeof child_process$ChildProcess; + + declare function exec( + command: string, + optionsOrCallback?: child_process$execOpts | child_process$execCallback, + callback?: child_process$execCallback + ): child_process$ChildProcess; + + declare function execSync( + command: string, + options: { + encoding: buffer$NonBufferEncoding, + ... + } & child_process$execSyncOpts + ): string; + + declare function execSync( + command: string, + options?: child_process$execSyncOpts + ): Buffer; + + declare function execFile( + file: string, + argsOrOptionsOrCallback?: + | Array + | child_process$execFileOpts + | child_process$execFileCallback, + optionsOrCallback?: + | child_process$execFileOpts + | child_process$execFileCallback, + callback?: child_process$execFileCallback + ): child_process$ChildProcess; + + declare function execFileSync( + command: string, + argsOrOptions?: Array | child_process$execFileSyncOpts, + options?: child_process$execFileSyncOpts + ): Buffer | string; + + declare function fork( + modulePath: string, + argsOrOptions?: Array | child_process$forkOpts, + options?: child_process$forkOpts + ): child_process$ChildProcess; + + declare function spawn( + command: string, + argsOrOptions?: Array | child_process$spawnOpts, + options?: child_process$spawnOpts + ): child_process$ChildProcess; + + declare function spawnSync( + command: string, + argsOrOptions?: Array | child_process$spawnSyncOpts, + options?: child_process$spawnSyncOpts + ): child_process$spawnSyncRet; +} + +declare module 'cluster' { + declare type ClusterSettings = { + execArgv: Array, + exec: string, + args: Array, + cwd: string, + serialization: 'json' | 'advanced', + silent: boolean, + stdio: Array, + uid: number, + gid: number, + inspectPort: number | (() => number), + windowsHide: boolean, + ... + }; + + declare type ClusterSettingsOpt = { + execArgv?: Array, + exec?: string, + args?: Array, + cwd?: string, + serialization?: 'json' | 'advanced', + silent?: boolean, + stdio?: Array, + uid?: number, + gid?: number, + inspectPort?: number | (() => number), + windowsHide?: boolean, + ... + }; + + declare class Worker extends events$EventEmitter { + id: number; + process: child_process$ChildProcess; + suicide: boolean; + + disconnect(): void; + isConnected(): boolean; + isDead(): boolean; + kill(signal?: string): void; + send( + message: Object, + sendHandleOrCallback?: child_process$Handle | Function, + callback?: Function + ): boolean; + } + + declare class Cluster extends events$EventEmitter { + isMaster: boolean; + isWorker: boolean; + settings: ClusterSettings; + worker: Worker; + workers: {[id: number]: Worker}; + + disconnect(callback?: () => void): void; + fork(env?: Object): Worker; + setupMaster(settings?: ClusterSettingsOpt): void; + } + + declare module.exports: Cluster; +} + +type crypto$createCredentialsDetails = any; // TODO + +declare class crypto$Cipher extends stream$Duplex { + final(output_encoding: 'latin1' | 'binary' | 'base64' | 'hex'): string; + final(output_encoding: void): Buffer; + getAuthTag(): Buffer; + setAAD(buffer: Buffer): crypto$Cipher; + setAuthTag(buffer: Buffer): void; + setAutoPadding(auto_padding?: boolean): crypto$Cipher; + update( + data: string, + input_encoding: 'utf8' | 'ascii' | 'latin1' | 'binary', + output_encoding: 'latin1' | 'binary' | 'base64' | 'hex' + ): string; + update( + data: string, + input_encoding: 'utf8' | 'ascii' | 'latin1' | 'binary', + output_encoding: void + ): Buffer; + update( + data: Buffer, + input_encoding: void | 'utf8' | 'ascii' | 'latin1' | 'binary', + output_encoding: 'latin1' | 'binary' | 'base64' | 'hex' + ): string; + update(data: Buffer, input_encoding: void, output_encoding: void): Buffer; +} + +type crypto$Credentials = {...}; + +type crypto$DiffieHellman = { + computeSecret( + other_public_key: string, + input_encoding?: string, + output_encoding?: string + ): any, + generateKeys(encoding?: string): any, + getGenerator(encoding?: string): any, + getPrime(encoding?: string): any, + getPrivateKey(encoding?: string): any, + getPublicKey(encoding?: string): any, + setPrivateKey(private_key: any, encoding?: string): void, + setPublicKey(public_key: any, encoding?: string): void, + ... +}; + +type crypto$ECDH$Encoding = 'latin1' | 'hex' | 'base64'; +type crypto$ECDH$Format = 'compressed' | 'uncompressed'; + +declare class crypto$ECDH { + computeSecret(other_public_key: Buffer | $TypedArray | DataView): Buffer; + computeSecret( + other_public_key: string, + input_encoding: crypto$ECDH$Encoding + ): Buffer; + computeSecret( + other_public_key: Buffer | $TypedArray | DataView, + output_encoding: crypto$ECDH$Encoding + ): string; + computeSecret( + other_public_key: string, + input_encoding: crypto$ECDH$Encoding, + output_encoding: crypto$ECDH$Encoding + ): string; + generateKeys(format?: crypto$ECDH$Format): Buffer; + generateKeys( + encoding: crypto$ECDH$Encoding, + format?: crypto$ECDH$Format + ): string; + getPrivateKey(): Buffer; + getPrivateKey(encoding: crypto$ECDH$Encoding): string; + getPublicKey(format?: crypto$ECDH$Format): Buffer; + getPublicKey( + encoding: crypto$ECDH$Encoding, + format?: crypto$ECDH$Format + ): string; + setPrivateKey(private_key: Buffer | $TypedArray | DataView): void; + setPrivateKey(private_key: string, encoding: crypto$ECDH$Encoding): void; +} + +declare class crypto$Decipher extends stream$Duplex { + final(output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8'): string; + final(output_encoding: void): Buffer; + getAuthTag(): Buffer; + setAAD(buffer: Buffer): void; + setAuthTag(buffer: Buffer): void; + setAutoPadding(auto_padding?: boolean): crypto$Cipher; + update( + data: string, + input_encoding: 'latin1' | 'binary' | 'base64' | 'hex', + output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8' + ): string; + update( + data: string, + input_encoding: 'latin1' | 'binary' | 'base64' | 'hex', + output_encoding: void + ): Buffer; + update( + data: Buffer, + input_encoding: void, + output_encoding: 'latin1' | 'binary' | 'ascii' | 'utf8' + ): string; + update(data: Buffer, input_encoding: void, output_encoding: void): Buffer; +} + +declare class crypto$Hash extends stream$Duplex { + digest(encoding: 'hex' | 'latin1' | 'binary' | 'base64'): string; + digest(encoding: 'buffer'): Buffer; + digest(encoding: void): Buffer; + update( + data: string | Buffer, + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary' + ): crypto$Hash; +} + +declare class crypto$Hmac extends stream$Duplex { + digest(encoding: 'hex' | 'latin1' | 'binary' | 'base64'): string; + digest(encoding: 'buffer'): Buffer; + digest(encoding: void): Buffer; + update( + data: string | Buffer, + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary' + ): crypto$Hmac; +} + +type crypto$Sign$private_key = + | string + | { + key: string, + passphrase: string, + ... + }; +declare class crypto$Sign extends stream$Writable { + static (algorithm: string, options?: writableStreamOptions): crypto$Sign; + constructor(algorithm: string, options?: writableStreamOptions): void; + sign( + private_key: crypto$Sign$private_key, + output_format: 'latin1' | 'binary' | 'hex' | 'base64' + ): string; + sign(private_key: crypto$Sign$private_key, output_format: void): Buffer; + update( + data: string | Buffer, + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary' + ): crypto$Sign; +} + +declare class crypto$Verify extends stream$Writable { + static (algorithm: string, options?: writableStreamOptions): crypto$Verify; + constructor(algorithm: string, options?: writableStreamOptions): void; + update( + data: string | Buffer, + input_encoding?: 'utf8' | 'ascii' | 'latin1' | 'binary' + ): crypto$Verify; + verify( + object: string, + signature: string | Buffer | $TypedArray | DataView, + signature_format: 'latin1' | 'binary' | 'hex' | 'base64' + ): boolean; + verify(object: string, signature: Buffer, signature_format: void): boolean; +} + +type crypto$key = + | string + | { + key: string, + passphrase?: string, + // TODO: enum type in crypto.constants + padding?: string, + ... + }; + +declare module 'crypto' { + declare var DEFAULT_ENCODING: string; + + declare class Sign extends crypto$Sign {} + declare class Verify extends crypto$Verify {} + + declare function createCipher( + algorithm: string, + password: string | Buffer + ): crypto$Cipher; + declare function createCipheriv( + algorithm: string, + key: string | Buffer, + iv: string | Buffer + ): crypto$Cipher; + declare function createCredentials( + details?: crypto$createCredentialsDetails + ): crypto$Credentials; + declare function createDecipher( + algorithm: string, + password: string | Buffer + ): crypto$Decipher; + declare function createDecipheriv( + algorithm: string, + key: string | Buffer, + iv: string | Buffer + ): crypto$Decipher; + declare function createDiffieHellman( + prime_length: number + ): crypto$DiffieHellman; + declare function createDiffieHellman( + prime: number, + encoding?: string + ): crypto$DiffieHellman; + declare function createECDH(curveName: string): crypto$ECDH; + declare function createHash(algorithm: string): crypto$Hash; + declare function createHmac( + algorithm: string, + key: string | Buffer + ): crypto$Hmac; + declare function createSign(algorithm: string): crypto$Sign; + declare function createVerify(algorithm: string): crypto$Verify; + declare function getCiphers(): Array; + declare function getCurves(): Array; + declare function getDiffieHellman(group_name: string): crypto$DiffieHellman; + declare function getHashes(): Array; + declare function pbkdf2( + password: string | Buffer, + salt: string | Buffer, + iterations: number, + keylen: number, + digest: string, + callback: (err: ?Error, derivedKey: Buffer) => void + ): void; + declare function pbkdf2( + password: string | Buffer, + salt: string | Buffer, + iterations: number, + keylen: number, + callback: (err: ?Error, derivedKey: Buffer) => void + ): void; + declare function pbkdf2Sync( + password: string | Buffer, + salt: string | Buffer, + iterations: number, + keylen: number, + digest?: string + ): Buffer; + declare function scrypt( + password: string | Buffer, + salt: string | Buffer, + keylen: number, + options: + | {|N?: number, r?: number, p?: number, maxmem?: number|} + | {| + cost?: number, + blockSize?: number, + parallelization?: number, + maxmem?: number, + |}, + callback: (err: ?Error, derivedKey: Buffer) => void + ): void; + declare function scrypt( + password: string | Buffer, + salt: string | Buffer, + keylen: number, + callback: (err: ?Error, derivedKey: Buffer) => void + ): void; + declare function scryptSync( + password: string | Buffer, + salt: string | Buffer, + keylen: number, + options?: + | {|N?: number, r?: number, p?: number, maxmem?: number|} + | {| + cost?: number, + blockSize?: number, + parallelization?: number, + maxmem?: number, + |} + ): Buffer; + declare function privateDecrypt( + private_key: crypto$key, + buffer: Buffer + ): Buffer; + declare function privateEncrypt( + private_key: crypto$key, + buffer: Buffer + ): Buffer; + declare function publicDecrypt(key: crypto$key, buffer: Buffer): Buffer; + declare function publicEncrypt(key: crypto$key, buffer: Buffer): Buffer; + // `UNUSED` argument strictly enforces arity to enable overloading this + // function with 1-arg and 2-arg variants. + declare function pseudoRandomBytes(size: number, UNUSED: void): Buffer; + declare function pseudoRandomBytes( + size: number, + callback: (err: ?Error, buffer: Buffer) => void + ): void; + // `UNUSED` argument strictly enforces arity to enable overloading this + // function with 1-arg and 2-arg variants. + declare function randomBytes(size: number, UNUSED: void): Buffer; + declare function randomBytes( + size: number, + callback: (err: ?Error, buffer: Buffer) => void + ): void; + declare function randomFillSync( + buffer: Buffer | $TypedArray | DataView + ): void; + declare function randomFillSync( + buffer: Buffer | $TypedArray | DataView, + offset: number + ): void; + declare function randomFillSync( + buffer: Buffer | $TypedArray | DataView, + offset: number, + size: number + ): void; + declare function randomFill( + buffer: Buffer | $TypedArray | DataView, + callback: (err: ?Error, buffer: Buffer) => void + ): void; + declare function randomFill( + buffer: Buffer | $TypedArray | DataView, + offset: number, + callback: (err: ?Error, buffer: Buffer) => void + ): void; + declare function randomFill( + buffer: Buffer | $TypedArray | DataView, + offset: number, + size: number, + callback: (err: ?Error, buffer: Buffer) => void + ): void; + declare function randomUUID( + options?: $ReadOnly<{|disableEntropyCache?: boolean|}> + ): string; + declare function timingSafeEqual( + a: Buffer | $TypedArray | DataView, + b: Buffer | $TypedArray | DataView + ): boolean; +} + +type net$Socket$address = { + address: string, + family: string, + port: number, + ... +}; +type dgram$Socket$rinfo = { + address: string, + family: 'IPv4' | 'IPv6', + port: number, + size: number, + ... +}; + +declare class dgram$Socket extends events$EventEmitter { + addMembership(multicastAddress: string, multicastInterface?: string): void; + address(): net$Socket$address; + bind(port?: number, address?: string, callback?: () => void): void; + close(callback?: () => void): void; + dropMembership(multicastAddress: string, multicastInterface?: string): void; + ref(): void; + send( + msg: Buffer, + port: number, + address: string, + callback?: (err: ?Error, bytes: any) => mixed + ): void; + send( + msg: Buffer, + offset: number, + length: number, + port: number, + address: string, + callback?: (err: ?Error, bytes: any) => mixed + ): void; + setBroadcast(flag: boolean): void; + setMulticastLoopback(flag: boolean): void; + setMulticastTTL(ttl: number): void; + setTTL(ttl: number): void; + unref(): void; +} + +declare module 'dgram' { + declare function createSocket( + options: string | {type: string, ...}, + callback?: () => void + ): dgram$Socket; +} + +declare module 'dns' { + declare var ADDRGETNETWORKPARAMS: string; + declare var BADFAMILY: string; + declare var BADFLAGS: string; + declare var BADHINTS: string; + declare var BADQUERY: string; + declare var BADNAME: string; + declare var BADRESP: string; + declare var BADSTR: string; + declare var CANCELLED: string; + declare var CONNREFUSED: string; + declare var DESTRUCTION: string; + declare var EOF: string; + declare var FILE: string; + declare var FORMER: string; + declare var LOADIPHLPAPI: string; + declare var NODATA: string; + declare var NOMEM: string; + declare var NONAME: string; + declare var NOTFOUND: string; + declare var NOTIMP: string; + declare var NOTINITIALIZED: string; + declare var REFUSED: string; + declare var SERVFAIL: string; + declare var TIMEOUT: string; + declare var ADDRCONFIG: number; + declare var V4MAPPED: number; + + declare type LookupOptions = { + family?: number, + hints?: number, + verbatim?: boolean, + all?: boolean, + ... + }; + + declare function lookup( + domain: string, + options: number | LookupOptions, + callback: (err: ?Error, address: string, family: number) => void + ): void; + declare function lookup( + domain: string, + callback: (err: ?Error, address: string, family: number) => void + ): void; + + declare function resolve( + domain: string, + rrtype?: string, + callback?: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolve4( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolve6( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolveCname( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolveMx( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolveNs( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolveSrv( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function resolveTxt( + domain: string, + callback: (err: ?Error, addresses: Array) => void + ): void; + + declare function reverse( + ip: string, + callback: (err: ?Error, domains: Array) => void + ): void; + declare function timingSafeEqual( + a: Buffer | $TypedArray | DataView, + b: Buffer | $TypedArray | DataView + ): boolean; +} + +declare class events$EventEmitter { + // deprecated + static listenerCount(emitter: events$EventEmitter, event: string): number; + static defaultMaxListeners: number; + + addListener(event: string, listener: Function): this; + emit(event: string, ...args: Array): boolean; + eventNames(): Array; + listeners(event: string): Array; + listenerCount(event: string): number; + on(event: string, listener: Function): this; + once(event: string, listener: Function): this; + prependListener(event: string, listener: Function): this; + prependOnceListener(event: string, listener: Function): this; + removeAllListeners(event?: string): this; + removeListener(event: string, listener: Function): this; + off(event: string, listener: Function): this; + setMaxListeners(n: number): this; + getMaxListeners(): number; + rawListeners(event: string): Array; +} + +declare module 'events' { + // TODO: See the comment above the events$EventEmitter declaration + declare class EventEmitter extends events$EventEmitter { + static EventEmitter: typeof EventEmitter; + } + + declare module.exports: typeof EventEmitter; +} + +declare class domain$Domain extends events$EventEmitter { + members: Array; + + add(emitter: events$EventEmitter): void; + bind(callback: Function): Function; + dispose(): void; + enter(): void; + exit(): void; + intercept(callback: Function): Function; + remove(emitter: events$EventEmitter): void; + run(fn: Function): void; +} + +declare module 'domain' { + declare function create(): domain$Domain; +} + +declare module 'fs' { + declare class Stats { + dev: number; + ino: number; + mode: number; + nlink: number; + uid: number; + gid: number; + rdev: number; + size: number; + blksize: number; + blocks: number; + atimeMs: number; + mtimeMs: number; + ctimeMs: number; + birthtimeMs: number; + atime: Date; + mtime: Date; + ctime: Date; + birthtime: Date; + + isFile(): boolean; + isDirectory(): boolean; + isBlockDevice(): boolean; + isCharacterDevice(): boolean; + isSymbolicLink(): boolean; + isFIFO(): boolean; + isSocket(): boolean; + } + + declare type PathLike = string | Buffer | URL; + + declare class FSWatcher extends events$EventEmitter { + close(): void; + } + + declare class ReadStream extends stream$Readable { + close(): void; + } + + declare class WriteStream extends stream$Writable { + close(): void; + bytesWritten: number; + } + + declare class Dirent { + name: string | Buffer; + + isBlockDevice(): boolean; + isCharacterDevice(): boolean; + isDirectory(): boolean; + isFIFO(): boolean; + isFile(): boolean; + isSocket(): boolean; + isSymbolicLink(): boolean; + } + + declare function rename( + oldPath: string, + newPath: string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function renameSync(oldPath: string, newPath: string): void; + declare function ftruncate( + fd: number, + len: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function ftruncateSync(fd: number, len: number): void; + declare function truncate( + path: string, + len: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function truncateSync(path: string, len: number): void; + declare function chown( + path: string, + uid: number, + gid: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function chownSync(path: string, uid: number, gid: number): void; + declare function fchown( + fd: number, + uid: number, + gid: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function fchownSync(fd: number, uid: number, gid: number): void; + declare function lchown( + path: string, + uid: number, + gid: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function lchownSync(path: string, uid: number, gid: number): void; + declare function chmod( + path: string, + mode: number | string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function chmodSync(path: string, mode: number | string): void; + declare function fchmod( + fd: number, + mode: number | string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function fchmodSync(fd: number, mode: number | string): void; + declare function lchmod( + path: string, + mode: number | string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function lchmodSync(path: string, mode: number | string): void; + declare function stat( + path: string, + callback?: (err: ?ErrnoError, stats: Stats) => any + ): void; + declare function statSync(path: string): Stats; + declare function fstat( + fd: number, + callback?: (err: ?ErrnoError, stats: Stats) => any + ): void; + declare function fstatSync(fd: number): Stats; + declare function lstat( + path: string, + callback?: (err: ?ErrnoError, stats: Stats) => any + ): void; + declare function lstatSync(path: string): Stats; + declare function link( + srcpath: string, + dstpath: string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function linkSync(srcpath: string, dstpath: string): void; + declare function symlink( + srcpath: string, + dtspath: string, + type?: string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function symlinkSync( + srcpath: string, + dstpath: string, + type?: string + ): void; + declare function readlink( + path: string, + callback: (err: ?ErrnoError, linkString: string) => void + ): void; + declare function readlinkSync(path: string): string; + declare function realpath( + path: string, + cache?: Object, + callback?: (err: ?ErrnoError, resolvedPath: string) => void + ): void; + declare function realpathSync(path: string, cache?: Object): string; + declare function unlink( + path: string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function unlinkSync(path: string): void; + + declare type RmDirOptions = {| + /** + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or + * `EPERM` error is encountered, Node.js will retry the operation with a linear + * backoff wait of `retryDelay` ms longer on each try. This option represents the + * number of retries. This option is ignored if the `recursive` option is not + * `true`. + * @default 0 + */ + maxRetries?: number | void, + /** + * @deprecated since v14.14.0 In future versions of Node.js and will trigger a warning + * `fs.rmdir(path, { recursive: true })` will throw if `path` does not exist or is a file. + * Use `fs.rm(path, { recursive: true, force: true })` instead. + * + * If `true`, perform a recursive directory removal. In + * recursive mode soperations are retried on failure. + * @default false + */ + recursive?: boolean | void, + /** + * The amount of time in milliseconds to wait between retries. + * This option is ignored if the `recursive` option is not `true`. + * @default 100 + */ + retryDelay?: number | void, + |}; + + declare function rmdir( + path: PathLike, + callback?: (err: ?ErrnoError) => void + ): void; + declare function rmdir( + path: PathLike, + options: RmDirOptions, + callback?: (err: ?ErrnoError) => void + ): void; + declare function rmdirSync(path: PathLike, options?: RmDirOptions): void; + + declare type RmOptions = {| + /** + * When `true`, exceptions will be ignored if `path` does not exist. + * @default false + */ + force?: boolean | void, + /** + * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or + * `EPERM` error is encountered, Node.js will retry the operation with a linear + * backoff wait of `retryDelay` ms longer on each try. This option represents the + * number of retries. This option is ignored if the `recursive` option is not + * `true`. + * @default 0 + */ + maxRetries?: number | void, + /** + * If `true`, perform a recursive directory removal. In + * recursive mode, operations are retried on failure. + * @default false + */ + recursive?: boolean | void, + /** + * The amount of time in milliseconds to wait between retries. + * This option is ignored if the `recursive` option is not `true`. + * @default 100 + */ + retryDelay?: number | void, + |}; + + /** + * Asynchronously removes files and directories (modeled on the standard POSIX `rm`utility). No arguments other than a possible exception are given to the + * completion callback. + * @since v14.14.0 + */ + declare function rm( + path: PathLike, + callback?: (err: ?ErrnoError) => void + ): void; + declare function rm( + path: PathLike, + options: RmOptions, + callback?: (err: ?ErrnoError) => void + ): void; + + /** + * Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`. + * @since v14.14.0 + */ + declare function rmSync(path: PathLike, options?: RmOptions): void; + + declare function mkdir( + path: string, + mode?: + | number + | { + recursive?: boolean, + mode?: number, + ... + }, + callback?: (err: ?ErrnoError) => void + ): void; + declare function mkdirSync( + path: string, + mode?: + | number + | { + recursive?: boolean, + mode?: number, + ... + } + ): void; + declare function mkdtemp( + prefix: string, + callback: (err: ?ErrnoError, folderPath: string) => void + ): void; + declare function mkdtempSync(prefix: string): string; + declare function readdir( + path: string, + options: string | {encoding?: string, withFileTypes?: false, ...}, + callback: (err: ?ErrnoError, files: Array) => void + ): void; + declare function readdir( + path: string, + options: {encoding?: string, withFileTypes: true, ...}, + callback: (err: ?ErrnoError, files: Array) => void + ): void; + declare function readdir( + path: string, + callback: (err: ?ErrnoError, files: Array) => void + ): void; + declare function readdirSync( + path: string, + options?: string | {encoding?: string, withFileTypes?: false, ...} + ): Array; + declare function readdirSync( + path: string, + options?: string | {encoding?: string, withFileTypes: true, ...} + ): Array; + declare function close( + fd: number, + callback: (err: ?ErrnoError) => void + ): void; + declare function closeSync(fd: number): void; + declare function open( + path: string | Buffer | URL, + flags: string | number, + mode: number, + callback: (err: ?ErrnoError, fd: number) => void + ): void; + declare function open( + path: string | Buffer | URL, + flags: string | number, + callback: (err: ?ErrnoError, fd: number) => void + ): void; + declare function openSync( + path: string | Buffer, + flags: string | number, + mode?: number + ): number; + declare function utimes( + path: string, + atime: number, + mtime: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function utimesSync(path: string, atime: number, mtime: number): void; + declare function futimes( + fd: number, + atime: number, + mtime: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function futimesSync(fd: number, atime: number, mtime: number): void; + declare function fsync( + fd: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function fsyncSync(fd: number): void; + declare function write( + fd: number, + buffer: Buffer, + offset: number, + length: number, + position: number, + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void + ): void; + declare function write( + fd: number, + buffer: Buffer, + offset: number, + length: number, + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void + ): void; + declare function write( + fd: number, + buffer: Buffer, + offset: number, + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void + ): void; + declare function write( + fd: number, + buffer: Buffer, + callback: (err: ?ErrnoError, write: number, buf: Buffer) => void + ): void; + declare function write( + fd: number, + data: string, + position: number, + encoding: string, + callback: (err: ?ErrnoError, write: number, str: string) => void + ): void; + declare function write( + fd: number, + data: string, + position: number, + callback: (err: ?ErrnoError, write: number, str: string) => void + ): void; + declare function write( + fd: number, + data: string, + callback: (err: ?ErrnoError, write: number, str: string) => void + ): void; + declare function writeSync( + fd: number, + buffer: Buffer, + offset: number, + length: number, + position: number + ): number; + declare function writeSync( + fd: number, + buffer: Buffer, + offset: number, + length: number + ): number; + declare function writeSync( + fd: number, + buffer: Buffer, + offset?: number + ): number; + declare function writeSync( + fd: number, + str: string, + position: number, + encoding: string + ): number; + declare function writeSync( + fd: number, + str: string, + position?: number + ): number; + declare function read( + fd: number, + buffer: Buffer, + offset: number, + length: number, + position: ?number, + callback: (err: ?ErrnoError, bytesRead: number, buffer: Buffer) => void + ): void; + declare function readSync( + fd: number, + buffer: Buffer, + offset: number, + length: number, + position: number + ): number; + declare function readFile( + path: string | Buffer | URL | number, + callback: (err: ?ErrnoError, data: Buffer) => void + ): void; + declare function readFile( + path: string | Buffer | URL | number, + encoding: string, + callback: (err: ?ErrnoError, data: string) => void + ): void; + declare function readFile( + path: string | Buffer | URL | number, + options: { + encoding: string, + flag?: string, + ... + }, + callback: (err: ?ErrnoError, data: string) => void + ): void; + declare function readFile( + path: string | Buffer | URL | number, + options: {encoding?: null | void, flag?: string, ...}, + callback: (err: ?ErrnoError, data: Buffer) => void + ): void; + declare function readFileSync(path: string | Buffer | URL | number): Buffer; + declare function readFileSync( + path: string | Buffer | URL | number, + encoding: string + ): string; + declare function readFileSync( + path: string | Buffer | URL | number, + options: { + encoding: string, + flag?: string, + ... + } + ): string; + declare function readFileSync( + path: string | Buffer | URL | number, + options: { + encoding?: void, + flag?: string, + ... + } + ): Buffer; + declare function writeFile( + filename: string | Buffer | number, + data: Buffer | string, + options: + | string + | { + encoding?: ?string, + mode?: number, + flag?: string, + ... + }, + callback: (err: ?ErrnoError) => void + ): void; + declare function writeFile( + filename: string | Buffer | number, + data: Buffer | string, + callback?: (err: ?ErrnoError) => void + ): void; + declare function writeFileSync( + filename: string, + data: Buffer | string, + options?: + | string + | { + encoding?: ?string, + mode?: number, + flag?: string, + ... + } + ): void; + declare function appendFile( + filename: string | Buffer | number, + data: string | Buffer, + options: + | string + | { + encoding?: ?string, + mode?: number, + flag?: string, + ... + }, + callback: (err: ?ErrnoError) => void + ): void; + declare function appendFile( + filename: string | Buffer | number, + data: string | Buffer, + callback: (err: ?ErrnoError) => void + ): void; + declare function appendFileSync( + filename: string | Buffer | number, + data: string | Buffer, + options?: + | string + | { + encoding?: ?string, + mode?: number, + flag?: string, + ... + } + ): void; + declare function watchFile( + filename: string, + options?: Object, + listener?: (curr: Stats, prev: Stats) => void + ): void; + declare function unwatchFile( + filename: string, + listener?: (curr: Stats, prev: Stats) => void + ): void; + declare function watch( + filename: string, + options?: Object, + listener?: (event: string, filename: string) => void + ): FSWatcher; + declare function exists( + path: string, + callback?: (exists: boolean) => void + ): void; + declare function existsSync(path: string): boolean; + declare function access( + path: string, + mode?: number, + callback?: (err: ?ErrnoError) => void + ): void; + declare function accessSync(path: string, mode?: number): void; + declare function createReadStream(path: string, options?: Object): ReadStream; + declare function createWriteStream( + path: string, + options?: Object + ): WriteStream; + declare function fdatasync( + fd: number, + callback: (err: ?ErrnoError) => void + ): void; + declare function fdatasyncSync(fd: number): void; + declare function copyFile( + src: string, + dest: string, + callback: (err: ErrnoError) => void + ): void; + declare function copyFile( + src: string, + dest: string, + flags?: number, + callback: (err: ErrnoError) => void + ): void; + declare function copyFileSync( + src: string, + dest: string, + flags?: number + ): void; + + declare type GlobOptions = $ReadOnly<{ + /** + * Current working directory. + * @default process.cwd() + */ + cwd?: string | void, + /** + * `true` if the glob should return paths as `Dirent`s, `false` otherwise. + * @default false + * @since v22.2.0 + */ + withFileTypes?: WithFileTypes, + /** + * Function to filter out files/directories or a + * list of glob patterns to be excluded. If a function is provided, return + * `true` to exclude the item, `false` to include it. + * @default undefined + */ + exclude?: + | ((fileName: Node$Conditional) => boolean) + | $ReadOnlyArray, + ... + }>; + + /** + * Retrieves the files matching the specified pattern. + * + * ```js + * import { glob } from 'node:fs'; + * + * glob('*.js', (err, matches) => { + * if (err) throw err; + * console.log(matches); + * }); + * ``` + * @since v22.0.0 + */ + declare function glob( + pattern: string | $ReadOnlyArray, + callback: (err: ?ErrnoError, matches: Array) => void + ): void; + + declare function glob( + pattern: string | $ReadOnlyArray, + options: GlobOptions, + callback: ( + err: ?ErrnoError, + matches: Node$Conditional, Array> + ) => void + ): void; + + /** + * ```js + * import { globSync } from 'node:fs'; + * + * console.log(globSync('*.js')); + * ``` + * @since v22.0.0 + * @returns paths of files that match the pattern. + */ + declare function globSync( + pattern: string | $ReadOnlyArray, + options?: GlobOptions + ): Node$Conditional, Array>; + + declare var F_OK: number; + declare var R_OK: number; + declare var W_OK: number; + declare var X_OK: number; + // new var from node 6.x + // https://nodejs.org/dist/latest-v6.x/docs/api/fs.html#fs_fs_constants_1 + declare var constants: { + F_OK: number, // 0 + R_OK: number, // 4 + W_OK: number, // 2 + X_OK: number, // 1 + COPYFILE_EXCL: number, // 1 + COPYFILE_FICLONE: number, // 2 + COPYFILE_FICLONE_FORCE: number, // 4 + O_RDONLY: number, // 0 + O_WRONLY: number, // 1 + O_RDWR: number, // 2 + S_IFMT: number, // 61440 + S_IFREG: number, // 32768 + S_IFDIR: number, // 16384 + S_IFCHR: number, // 8192 + S_IFBLK: number, // 24576 + S_IFIFO: number, // 4096 + S_IFLNK: number, // 40960 + S_IFSOCK: number, // 49152 + O_CREAT: number, // 64 + O_EXCL: number, // 128 + O_NOCTTY: number, // 256 + O_TRUNC: number, // 512 + O_APPEND: number, // 1024 + O_DIRECTORY: number, // 65536 + O_NOATIME: number, // 262144 + O_NOFOLLOW: number, // 131072 + O_SYNC: number, // 1052672 + O_DSYNC: number, // 4096 + O_SYMLINK: number, // 2097152 + O_DIRECT: number, // 16384 + O_NONBLOCK: number, // 2048 + S_IRWXU: number, // 448 + S_IRUSR: number, // 256 + S_IWUSR: number, // 128 + S_IXUSR: number, // 64 + S_IRWXG: number, // 56 + S_IRGRP: number, // 32 + S_IWGRP: number, // 16 + S_IXGRP: number, // 8 + S_IRWXO: number, // 7 + S_IROTH: number, // 4 + S_IWOTH: number, // 2 + S_IXOTH: number, // 1 + ... + }; + + declare type BufferEncoding = 'buffer' | {encoding: 'buffer', ...}; + declare type EncodingOptions = {encoding?: string, ...}; + declare type EncodingFlag = EncodingOptions & {flag?: string, ...}; + declare type WriteOptions = EncodingFlag & {mode?: number, ...}; + declare type RemoveOptions = { + force?: boolean, + maxRetries?: number, + recursive?: boolean, + retryDelay?: number, + ... + }; + declare class FileHandle { + appendFile( + data: string | Buffer, + options: WriteOptions | string + ): Promise; + chmod(mode: number): Promise; + chown(uid: number, guid: number): Promise; + close(): Promise; + datasync(): Promise; + fd: number; + read( + buffer: T, + offset: number, + length: number, + position: number + ): Promise<{ + bytesRead: number, + buffer: T, + ... + }>; + readFile(options: EncodingFlag): Promise; + readFile(options: string): Promise; + stat(): Promise; + sync(): Promise; + truncate(len?: number): Promise; + utimes( + atime: number | string | Date, + mtime: number | string | Date + ): Promise; + write( + buffer: Buffer | Uint8Array, + offset: number, + length: number, + position: number + ): Promise; + writeFile( + data: string | Buffer | Uint8Array, + options: WriteOptions | string + ): Promise; + } + + declare type FSPromisePath = string | Buffer | URL; + declare type FSPromise = { + access(path: FSPromisePath, mode?: number): Promise, + appendFile( + path: FSPromisePath | FileHandle, + data: string | Buffer, + options?: WriteOptions | string + ): Promise, + chmod(path: FSPromisePath, mode: number): Promise, + chown(path: FSPromisePath, uid: number, gid: number): Promise, + copyFile( + src: FSPromisePath, + dest: FSPromisePath, + flags?: number + ): Promise, + fchmod(filehandle: FileHandle, mode: number): Promise, + fchown(filehandle: FileHandle, uid: number, guid: number): Promise, + fdatasync(filehandle: FileHandle): Promise, + fstat(filehandle: FileHandle): Promise, + fsync(filehandle: FileHandle): Promise, + ftruncate(filehandle: FileHandle, len?: number): Promise, + futimes( + filehandle: FileHandle, + atime: number | string | Date, + mtime: number | string | Date + ): Promise, + lchmod(path: FSPromisePath, mode: number): Promise, + glob( + pattern: string | $ReadOnlyArray, + options?: GlobOptions + ): Node$Conditional< + WithFileTypes, + AsyncIterator, + AsyncIterator, + >, + lchown(path: FSPromisePath, uid: number, guid: number): Promise, + link(existingPath: FSPromisePath, newPath: FSPromisePath): Promise, + lstat(path: FSPromisePath): Promise, + mkdir( + path: FSPromisePath, + mode?: + | number + | { + recursive?: boolean, + mode?: number, + ... + } + ): Promise, + mkdtemp(prefix: string, options?: EncodingOptions): Promise, + open( + path: FSPromisePath, + flags?: string | number, + mode?: number + ): Promise, + read( + filehandle: FileHandle, + buffer: T, + offset: number, + length: number, + position?: number + ): Promise<{ + bytesRead: number, + buffer: T, + ... + }>, + readdir: (( + path: FSPromisePath, + options: string | {encoding?: string, withFileTypes?: false, ...} + ) => Promise>) & + (( + path: FSPromisePath, + options: {encoding?: string, withFileTypes: true, ...} + ) => Promise>) & + ((path: FSPromisePath) => Promise>), + readFile: (( + path: FSPromisePath | FileHandle, + options: string + ) => Promise) & + (( + path: FSPromisePath | FileHandle, + options?: EncodingFlag + ) => Promise), + readlink: (( + path: FSPromisePath, + options: BufferEncoding + ) => Promise) & + (( + path: FSPromisePath, + options?: string | EncodingOptions + ) => Promise), + realpath: (( + path: FSPromisePath, + options: BufferEncoding + ) => Promise) & + (( + path: FSPromisePath, + options?: string | EncodingOptions + ) => Promise), + rename(oldPath: FSPromisePath, newPath: FSPromisePath): Promise, + rm(path: FSPromisePath, options?: RemoveOptions): Promise, + rmdir(path: FSPromisePath): Promise, + stat(path: FSPromisePath): Promise, + symlink( + target: FSPromisePath, + path: FSPromisePath, + type?: 'dir' | 'file' | 'junction' + ): Promise, + truncate(path: FSPromisePath, len?: number): Promise, + unlink(path: FSPromisePath): Promise, + utimes( + path: FSPromisePath, + atime: number | string | Date, + mtime: number | string | Date + ): Promise, + write( + filehandle: FileHandle, + buffer: T, + offset: number, + length: number, + position?: number + ): Promise<{ + bytesRead: number, + buffer: T, + ... + }>, + writeFile( + FSPromisePath | FileHandle, + data: string | Buffer | Uint8Array, + options?: string | WriteOptions + ): Promise, + ... + }; + + declare var promises: FSPromise; +} + +type http$agentOptions = { + keepAlive?: boolean, + keepAliveMsecs?: number, + maxSockets?: number, + maxFreeSockets?: number, + ... +}; + +declare class http$Agent<+SocketT = net$Socket> { + constructor(options: http$agentOptions): void; + destroy(): void; + freeSockets: {[name: string]: $ReadOnlyArray, ...}; + getName(options: { + host: string, + port: number, + localAddress: string, + ... + }): string; + maxFreeSockets: number; + maxSockets: number; + requests: {[name: string]: $ReadOnlyArray>, ...}; + sockets: {[name: string]: $ReadOnlyArray, ...}; +} + +declare class http$IncomingMessage + extends stream$Readable +{ + headers: Object; + rawHeaders: Array; + httpVersion: string; + method: string; + trailers: Object; + setTimeout(msecs: number, callback: Function): void; + socket: SocketT; + statusCode: number; + statusMessage: string; + url: string; + aborted: boolean; + complete: boolean; + rawTrailers: Array; +} + +declare class http$ClientRequest<+SocketT = net$Socket> + extends stream$Writable +{ + abort(): void; + aborted: boolean; + +connection: SocketT | null; + flushHeaders(): void; + getHeader(name: string): string; + removeHeader(name: string): void; + setHeader(name: string, value: string | Array): void; + setNoDelay(noDelay?: boolean): void; + setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; + setTimeout(msecs: number, callback?: Function): void; + +socket: SocketT | null; +} + +declare class http$ServerResponse extends stream$Writable { + addTrailers(headers: {[key: string]: string, ...}): void; + connection: net$Socket; + finished: boolean; + flushHeaders(): void; + getHeader(name: string): string; + getHeaderNames(): Array; + getHeaders(): {[key: string]: string | Array, ...}; + hasHeader(name: string): boolean; + headersSent: boolean; + removeHeader(name: string): void; + sendDate: boolean; + setHeader(name: string, value: string | Array): void; + setTimeout(msecs: number, callback?: Function): http$ServerResponse; + socket: net$Socket; + statusCode: number; + statusMessage: string; + writeContinue(): void; + writeHead( + status: number, + statusMessage?: string, + headers?: {[key: string]: string, ...} + ): void; + writeHead(status: number, headers?: {[key: string]: string, ...}): void; + writeProcessing(): void; +} + +declare class http$Server extends net$Server { + listen( + port?: number, + hostname?: string, + backlog?: number, + callback?: Function + ): this; + // The following signatures are added to allow omitting intermediate arguments + listen(port?: number, backlog?: number, callback?: Function): this; + listen(port?: number, hostname?: string, callback?: Function): this; + listen(port?: number, callback?: Function): this; + listen(path: string, callback?: Function): this; + listen( + handle: { + port?: number, + host?: string, + path?: string, + backlog?: number, + exclusive?: boolean, + readableAll?: boolean, + writableAll?: boolean, + ipv6Only?: boolean, + ... + }, + callback?: Function + ): this; + listening: boolean; + close(callback?: (error: ?Error) => mixed): this; + closeAllConnections(): void; + closeIdleConnections(): void; + maxHeadersCount: number; + keepAliveTimeout: number; + headersTimeout: number; + setTimeout(msecs: number, callback: Function): this; + timeout: number; +} + +declare class https$Server extends tls$Server { + listen( + port?: number, + hostname?: string, + backlog?: number, + callback?: Function + ): this; + // The following signatures are added to allow omitting intermediate arguments + listen(port?: number, backlog?: number, callback?: Function): this; + listen(port?: number, hostname?: string, callback?: Function): this; + listen(port?: number, callback?: Function): this; + listen(path: string, callback?: Function): this; + listen( + handle: { + port?: number, + host?: string, + path?: string, + backlog?: number, + exclusive?: boolean, + readableAll?: boolean, + writableAll?: boolean, + ipv6Only?: boolean, + ... + }, + callback?: Function + ): this; + close(callback?: (error: ?Error) => mixed): this; + closeAllConnections(): void; + closeIdleConnections(): void; + keepAliveTimeout: number; + headersTimeout: number; + setTimeout(msecs: number, callback: Function): this; + timeout: number; +} + +type requestOptions = {| + auth?: string, + defaultPort?: number, + family?: number, + headers?: {[key: string]: mixed, ...}, + host?: string, + hostname?: string, + localAddress?: string, + method?: string, + path?: string, + port?: number, + protocol?: string, + setHost?: boolean, + socketPath?: string, + timeout?: number, +|}; + +type http$requestOptions = { + ...requestOptions, + agent?: boolean | http$Agent, + createConnection?: ( + options: net$connectOptions, + callback?: Function + ) => net$Socket, + ... +}; + +declare module 'http' { + declare class Server extends http$Server {} + declare class Agent extends http$Agent { + createConnection( + options: net$connectOptions, + callback?: Function + ): net$Socket; + } + declare class ClientRequest extends http$ClientRequest {} + declare class IncomingMessage extends http$IncomingMessage {} + declare class ServerResponse extends http$ServerResponse {} + + declare function createServer( + requestListener?: ( + request: IncomingMessage, + response: ServerResponse + ) => void + ): Server; + declare function request( + options: http$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function request( + url: string, + options?: http$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function get( + options: http$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function get( + url: string, + options?: http$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + + declare var METHODS: Array; + declare var STATUS_CODES: {[key: number]: string, ...}; + declare var globalAgent: Agent; +} + +type https$requestOptions = { + ...requestOptions, + agent?: boolean | http$Agent, + createConnection?: ( + options: tls$connectOptions, + callback?: Function + ) => tls$TLSSocket, + ... +}; + +declare module 'https' { + declare class Server extends https$Server {} + declare class Agent extends http$Agent { + createConnection( + port: ?number, + host: ?string, + options: tls$connectOptions + ): tls$TLSSocket; + createConnection(port: ?number, options: tls$connectOptions): tls$TLSSocket; + createConnection(options: tls$connectOptions): tls$TLSSocket; + } + + declare class ClientRequest extends http$ClientRequest {} + declare class IncomingMessage extends http$IncomingMessage {} + declare class ServerResponse extends http$ServerResponse {} + + declare function createServer( + options: Object, + requestListener?: ( + request: IncomingMessage, + response: ServerResponse + ) => void + ): Server; + declare function request( + options: https$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function request( + url: string, + options?: https$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function get( + options: https$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + declare function get( + url: string, + options?: https$requestOptions, + callback?: (response: IncomingMessage) => void + ): ClientRequest; + + declare var globalAgent: Agent; +} + +type module$Module = { + builtinModules: Array, + createRequire(filename: string | URL): typeof require, + syncBuiltinESMExports(): void, + Module: module$Module, + ... +}; + +declare module 'module' { + declare module.exports: module$Module; +} + +declare class net$Socket extends stream$Duplex { + constructor(options?: Object): void; + address(): net$Socket$address; + bufferSize: number; + bytesRead: number; + bytesWritten: number; + connect(path: string, connectListener?: () => mixed): net$Socket; + connect( + port: number, + host?: string, + connectListener?: () => mixed + ): net$Socket; + connect(port: number, connectListener?: () => mixed): net$Socket; + connect(options: Object, connectListener?: () => mixed): net$Socket; + destroyed: boolean; + end( + chunkOrEncodingOrCallback?: + | Buffer + | Uint8Array + | string + | ((data: any) => void), + encodingOrCallback?: string | ((data: any) => void), + callback?: (data: any) => void + ): this; + localAddress: string; + localPort: number; + pause(): this; + ref(): this; + remoteAddress: string | void; + remoteFamily: string; + remotePort: number; + resume(): this; + setEncoding(encoding?: string): this; + setKeepAlive(enable?: boolean, initialDelay?: number): this; + setNoDelay(noDelay?: boolean): this; + setTimeout(timeout: number, callback?: Function): this; + unref(): this; + write( + chunk: Buffer | Uint8Array | string, + encodingOrCallback?: string | ((data: any) => void), + callback?: (data: any) => void + ): boolean; +} + +declare class net$Server extends events$EventEmitter { + listen( + port?: number, + hostname?: string, + backlog?: number, + callback?: Function + ): net$Server; + listen(path: string, callback?: Function): net$Server; + listen(handle: Object, callback?: Function): net$Server; + listening: boolean; + close(callback?: Function): net$Server; + address(): net$Socket$address; + connections: number; + maxConnections: number; + getConnections(callback: Function): void; + ref(): net$Server; + unref(): net$Server; +} + +type net$connectOptions = { + port?: number, + host?: string, + localAddress?: string, + localPort?: number, + family?: number, + lookup?: ( + domain: string, + options?: ?number | ?Object, + callback?: (err: ?Error, address: string, family: number) => void + ) => mixed, + path?: string, + ... +}; + +declare module 'net' { + declare class Server extends net$Server {} + declare class Socket extends net$Socket {} + + declare function isIP(input: string): number; + declare function isIPv4(input: string): boolean; + declare function isIPv6(input: string): boolean; + + declare type connectionListener = (socket: Socket) => any; + declare function createServer( + options?: + | { + allowHalfOpen?: boolean, + pauseOnConnect?: boolean, + ... + } + | connectionListener, + connectionListener?: connectionListener + ): Server; + + declare type connectListener = () => any; + declare function connect( + pathOrPortOrOptions: string | number | net$connectOptions, + hostOrConnectListener?: string | connectListener, + connectListener?: connectListener + ): Socket; + + declare function createConnection( + pathOrPortOrOptions: string | number | net$connectOptions, + hostOrConnectListener?: string | connectListener, + connectListener?: connectListener + ): Socket; +} + +type os$CPU = { + model: string, + speed: number, + times: { + idle: number, + irq: number, + nice: number, + sys: number, + user: number, + ... + }, + ... +}; + +type os$NetIFAddr = { + address: string, + family: string, + internal: boolean, + mac: string, + netmask: string, + ... +}; + +type os$UserInfo$buffer = { + uid: number, + gid: number, + username: Buffer, + homedir: Buffer, + shell: ?Buffer, + ... +}; + +type os$UserInfo$string = { + uid: number, + gid: number, + username: string, + homedir: string, + shell: ?string, + ... +}; + +declare module 'os' { + declare function arch(): 'x64' | 'arm' | 'ia32'; + declare function availableParallelism(): number; + declare function cpus(): Array; + declare function endianness(): 'BE' | 'LE'; + declare function freemem(): number; + declare function homedir(): string; + declare function hostname(): string; + declare function loadavg(): [number, number, number]; + declare function networkInterfaces(): { + [ifName: string]: Array, + ... + }; + declare function platform(): string; + declare function release(): string; + declare function tmpdir(): string; + declare function totalmem(): number; + declare function type(): string; + declare function uptime(): number; + declare function userInfo(options: { + encoding: 'buffer', + ... + }): os$UserInfo$buffer; + declare function userInfo(options?: { + encoding: 'utf8', + ... + }): os$UserInfo$string; + declare var EOL: string; +} + +declare module 'path' { + declare function normalize(path: string): string; + declare function join(...parts: Array): string; + declare function resolve(...parts: Array): string; + declare function isAbsolute(path: string): boolean; + declare function relative(from: string, to: string): string; + declare function dirname(path: string): string; + declare function basename(path: string, ext?: string): string; + declare function extname(path: string): string; + declare var sep: string; + declare var delimiter: string; + declare function parse(pathString: string): { + root: string, + dir: string, + base: string, + ext: string, + name: string, + ... + }; + declare function format(pathObject: { + root?: string, + dir?: string, + base?: string, + ext?: string, + name?: string, + ... + }): string; + declare var posix: any; + declare var win32: any; +} + +declare module 'punycode' { + declare function decode(string: string): string; + declare function encode(string: string): string; + declare function toASCII(domain: string): string; + declare function toUnicode(domain: string): string; + declare var ucs2: { + decode: (str: string) => Array, + encode: (codePoints: Array) => string, + ... + }; + declare var version: string; +} + +declare module 'querystring' { + declare function stringify( + obj: Object, + separator?: string, + equal?: string, + options?: {encodeURIComponent?: (str: string) => string, ...} + ): string; + declare function parse( + str: string, + separator: ?string, + equal: ?string, + options?: { + decodeURIComponent?: (str: string) => string, + maxKeys?: number, + ... + } + ): any; + declare function escape(str: string): string; + declare function unescape(str: string, decodeSpaces?: boolean): string; +} + +type readline$InterfaceCompleter = ( + line: string +) => + | [Array, string] + | (( + line: string, + ((err: ?Error, data: [Array, string]) => void) + ) => void); + +declare class readline$Interface extends events$EventEmitter { + close(): void; + pause(): void; + prompt(preserveCursor?: boolean): void; + question( + query: string, + optionsOrCallback: {|signal?: AbortSignal|} | ((answer: string) => void), + callback?: (answer: string) => void + ): void; + resume(): void; + setPrompt(prompt: string): void; + write( + val: string | void | null, + key?: { + name: string, + ctrl?: boolean, + shift?: boolean, + meta?: boolean, + ... + } + ): void; + @@asyncIterator(): AsyncIterator; +} + +declare module 'readline' { + declare var Interface: typeof readline$Interface; + declare function clearLine( + stream: stream$Stream, + dir: -1 | 1 | 0, + callback?: () => void + ): void; + declare function clearScreenDown( + stream: stream$Stream, + callback?: () => void + ): void; + declare function createInterface(opts: { + completer?: readline$InterfaceCompleter, + crlfDelay?: number, + escapeCodeTimeout?: number, + historySize?: number, + input: stream$Readable, + output?: ?stream$Stream, + prompt?: string, + removeHistoryDuplicates?: boolean, + terminal?: boolean, + ... + }): readline$Interface; + declare function cursorTo( + stream: stream$Stream, + x?: number, + y?: number, + callback?: () => void + ): void; + declare function moveCursor( + stream: stream$Stream, + dx: number, + dy: number, + callback?: () => void + ): void; + declare function emitKeypressEvents( + stream: stream$Stream, + readlineInterface?: readline$Interface + ): void; +} + +declare class stream$Stream extends events$EventEmitter {} + +type readableStreamOptions = { + highWaterMark?: number, + encoding?: string, + objectMode?: boolean, + read?: (size: number) => void, + destroy?: (error: ?Error, callback: (error?: Error) => void) => void, + autoDestroy?: boolean, + ... +}; +declare class stream$Readable extends stream$Stream { + static from( + iterable: Iterable | AsyncIterable, + options?: readableStreamOptions + ): stream$Readable; + + constructor(options?: readableStreamOptions): void; + destroy(error?: Error): this; + isPaused(): boolean; + pause(): this; + pipe(dest: T, options?: {end?: boolean, ...}): T; + read(size?: number): ?(string | Buffer); + readable: boolean; + readableHighWaterMark: number; + readableLength: number; + resume(): this; + setEncoding(encoding: string): this; + unpipe(dest?: stream$Writable): this; + unshift(chunk: Buffer | Uint8Array | string): void; + wrap(oldReadable: stream$Stream): this; + _read(size: number): void; + _destroy(error: ?Error, callback: (error?: Error) => void): void; + push(chunk: ?(Buffer | Uint8Array | string), encoding?: string): boolean; + @@asyncIterator(): AsyncIterator; +} + +type writableStreamOptions = { + highWaterMark?: number, + decodeStrings?: boolean, + defaultEncoding?: string, + objectMode?: boolean, + emitClose?: boolean, + write?: ( + chunk: Buffer | string, + encoding: string, + callback: (error?: Error) => void + ) => void, + writev?: ( + chunks: Array<{ + chunk: Buffer | string, + encoding: string, + ... + }>, + callback: (error?: Error) => void + ) => void, + destroy?: (error: ?Error, callback: (error?: Error) => void) => void, + final?: (callback: (error?: Error) => void) => void, + autoDestroy?: boolean, + ... +}; +declare class stream$Writable extends stream$Stream { + constructor(options?: writableStreamOptions): void; + cork(): void; + destroy(error?: Error): this; + end(callback?: () => void): this; + end(chunk?: string | Buffer | Uint8Array, callback?: () => void): this; + end( + chunk?: string | Buffer | Uint8Array, + encoding?: string, + callback?: () => void + ): this; + setDefaultEncoding(encoding: string): this; + uncork(): void; + writable: boolean; + writableHighWaterMark: number; + writableLength: number; + write( + chunk: string | Buffer | Uint8Array, + callback?: (error?: Error) => void + ): boolean; + write( + chunk: string | Buffer | Uint8Array, + encoding?: string, + callback?: (error?: Error) => void + ): boolean; + _write( + chunk: Buffer | string, + encoding: string, + callback: (error?: Error) => void + ): void; + _writev( + chunks: Array<{ + chunk: Buffer | string, + encoding: string, + ... + }>, + callback: (error?: Error) => void + ): void; + _destroy(error: ?Error, callback: (error?: Error) => void): void; + _final(callback: (error?: Error) => void): void; +} + +//According to the NodeJS docs: +//"Since JavaScript doesn't have multiple prototypal inheritance, this class +//prototypally inherits from Readable, and then parasitically from Writable." +//Source: void) => void, + transform?: ( + chunk: Buffer | string, + encoding: string, + callback: (error: ?Error, data: ?(Buffer | string)) => void + ) => void, + ... +}; +declare class stream$Transform extends stream$Duplex { + constructor(options?: transformStreamOptions): void; + _flush(callback: (error: ?Error, data: ?(Buffer | string)) => void): void; + _transform( + chunk: Buffer | string, + encoding: string, + callback: (error: ?Error, data: ?(Buffer | string)) => void + ): void; +} +declare class stream$PassThrough extends stream$Transform {} + +declare module 'stream' { + declare var Stream: typeof stream$Stream; + declare var Readable: typeof stream$Readable; + declare var Writable: typeof stream$Writable; + declare var Duplex: typeof stream$Duplex; + declare var Transform: typeof stream$Transform; + declare var PassThrough: typeof stream$PassThrough; + declare function finished( + stream: stream$Stream, + callback: (error?: Error) => void + ): () => void; + declare function finished( + stream: stream$Stream, + options: ?{ + error?: boolean, + readable?: boolean, + writable?: boolean, + ... + }, + callback: (error?: Error) => void + ): () => void; + declare function pipeline( + s1: stream$Readable, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + s1: stream$Readable, + s2: stream$Duplex, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + s5: stream$Duplex, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + s5: stream$Duplex, + s6: stream$Duplex, + last: T, + cb: (error?: Error) => void + ): T; + declare function pipeline( + streams: Array, + cb: (error?: Error) => void + ): stream$Stream; + + declare interface StreamPipelineOptions { + +signal?: AbortSignal; + +end?: boolean; + } + + declare type StreamPromise = { + pipeline( + s1: stream$Readable, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + s1: stream$Readable, + s2: stream$Duplex, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + s5: stream$Duplex, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + s1: stream$Readable, + s2: stream$Duplex, + s3: stream$Duplex, + s4: stream$Duplex, + s5: stream$Duplex, + s6: stream$Duplex, + last: stream$Writable, + options?: StreamPipelineOptions + ): Promise, + pipeline( + streams: $ReadOnlyArray, + options?: StreamPipelineOptions + ): Promise, + ... + }; + + declare var promises: StreamPromise; +} + +declare class tty$ReadStream extends net$Socket { + constructor(fd: number, options?: Object): void; + isRaw: boolean; + setRawMode(mode: boolean): void; + isTTY: true; +} +declare class tty$WriteStream extends net$Socket { + constructor(fd: number): void; + /** + * Clears the current line of this `WriteStream` in a direction identified by `dir`. + * + * TODO: takes a callback and returns `boolean` in v12+ + */ + clearLine(dir: -1 | 0 | 1): void; + columns: number; + /** + * Moves this WriteStream's cursor to the specified position + * + * TODO: takes a callback and returns `boolean` in v12+ + */ + cursorTo(x: number, y?: number): void; + isTTY: true; + /** + * Moves this WriteStream's cursor relative to its current position + * + * TODO: takes a callback and returns `boolean` in v12+ + */ + moveCursor(dx: number, dy: number): void; + rows: number; + + /** + * Clears this WriteStream from the current cursor down. + */ + clearScreenDown(callback?: () => void): boolean; + + /** + * 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. + * To enforce a specific color support, use one of the below environment settings. + * + * 2 colors: FORCE_COLOR = 0 (Disables colors) + * 16 colors: FORCE_COLOR = 1 + * 256 colors: FORCE_COLOR = 2 + * 16,777,216 colors: FORCE_COLOR = 3 + * Disabling color support is also possible by using the NO_COLOR and NODE_DISABLE_COLORS environment variables. + */ + getColorDepth(env?: typeof process.env): + | 1 // 2 + | 4 // 16 + | 8 // 256 + | 24; // 16,777,216 + + /** + * 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. + */ + getWindowSize(): [ + number, // columns + number, // rows + ]; + + /** + * - count The number of colors that are requested (minimum 2). Default: 16. + * - env An object containing the environment variables to check. This enables simulating the usage of a specific terminal. Default: process.env. + * - Returns: + * + * Returns true if the writeStream supports at least as many colors as provided in count. Minimum support is 2 (black and white). + * + * This has the same false positives and negatives as described in tty$WriteStream#getColorDepth(). + */ + hasColors(count?: number, env?: typeof process.env): boolean; +} + +declare module 'tty' { + declare function isatty(fd: number): boolean; + declare function setRawMode(mode: boolean): void; + declare var ReadStream: typeof tty$ReadStream; + declare var WriteStream: typeof tty$WriteStream; +} + +declare class string_decoder$StringDecoder { + constructor(encoding?: 'utf8' | 'ucs2' | 'utf16le' | 'base64'): void; + end(): string; + write(buffer: Buffer): string; +} + +declare module 'string_decoder' { + declare var StringDecoder: typeof string_decoder$StringDecoder; +} + +type tls$connectOptions = { + port?: number, + host?: string, + socket?: net$Socket, + rejectUnauthorized?: boolean, + path?: string, + lookup?: ( + domain: string, + options?: ?number | ?Object, + callback?: (err: ?Error, address: string, family: number) => void + ) => mixed, + requestOCSP?: boolean, + ... +}; + +type tls$Certificate$Subject = { + C?: string, + ST?: string, + L?: string, + O?: string, + OU?: string, + CN?: string, + ... +}; + +type tls$Certificate = { + raw: Buffer, + subject: tls$Certificate$Subject, + issuer: tls$Certificate$Subject, + valid_from: string, + valid_to: string, + serialNumber: string, + fingerprint: string, + fingerprint256: string, + ext_key_usage?: Array, + subjectaltname?: string, + infoAccess?: {[string]: Array, ...}, + issuerCertificate?: tls$Certificate, + ... +}; + +declare class tls$TLSSocket extends net$Socket { + constructor(socket: net$Socket, options?: Object): void; + authorized: boolean; + authorizationError: string | null; + encrypted: true; + getCipher(): { + name: string, + version: string, + ... + } | null; + getEphemeralKeyInfo(): + | { + type: 'DH', + size: number, + ... + } + | { + type: 'EDHC', + name: string, + size: number, + ... + } + | null; + getPeerCertificate(detailed?: boolean): tls$Certificate | null; + getSession(): ?Buffer; + getTLSTicket(): Buffer | void; + renegotiate(options: Object, callback: Function): boolean | void; + setMaxSendFragment(size: number): boolean; +} + +declare class tls$Server extends net$Server { + listen( + port?: number, + hostname?: string, + backlog?: number, + callback?: Function + ): tls$Server; + listen(path: string, callback?: Function): tls$Server; + listen(handle: Object, callback?: Function): tls$Server; + close(callback?: Function): tls$Server; + addContext(hostname: string, context: Object): void; + getTicketKeys(): Buffer; + setTicketKeys(keys: Buffer): void; +} + +declare module 'tls' { + declare var CLIENT_RENEG_LIMIT: number; + declare var CLIENT_RENEG_WINDOW: number; + declare var SLAB_BUFFER_SIZE: number; + declare var DEFAULT_CIPHERS: string; + declare var DEFAULT_ECDH_CURVE: string; + declare function getCiphers(): Array; + declare function convertNPNProtocols( + NPNProtocols: Array, + out: Object + ): void; + declare function checkServerIdentity( + servername: string, + cert: string + ): Error | void; + declare function parseCertString(s: string): Object; + declare function createSecureContext(details: Object): Object; + declare var SecureContext: Object; + declare var TLSSocket: typeof tls$TLSSocket; + declare var Server: typeof tls$Server; + declare function createServer( + options: Object, + secureConnectionListener?: Function + ): tls$Server; + declare function connect( + options: tls$connectOptions, + callback?: Function + ): tls$TLSSocket; + declare function connect( + port: number, + host?: string, + options?: tls$connectOptions, + callback?: Function + ): tls$TLSSocket; + declare function createSecurePair( + context?: Object, + isServer?: boolean, + requestCert?: boolean, + rejectUnauthorized?: boolean, + options?: Object + ): Object; +} + +type url$urlObject = { + +href?: string, + +protocol?: string | null, + +slashes?: boolean | null, + +auth?: string | null, + +hostname?: string | null, + +port?: string | number | null, + +host?: string | null, + +pathname?: string | null, + +search?: string | null, + +query?: Object | null, + +hash?: string | null, + ... +}; + +declare module 'url' { + declare type Url = {| + protocol: string | null, + slashes: boolean | null, + auth: string | null, + host: string | null, + port: string | null, + hostname: string | null, + hash: string | null, + search: string | null, + query: string | null | {[string]: string, ...}, + pathname: string | null, + path: string | null, + href: string, + |}; + + declare type UrlWithStringQuery = {| + ...Url, + query: string | null, + |}; + + declare type UrlWithParsedQuery = {| + ...Url, + query: {[string]: string, ...}, + |}; + + declare function parse( + urlStr: string, + parseQueryString: true, + slashesDenoteHost?: boolean + ): UrlWithParsedQuery; + declare function parse( + urlStr: string, + parseQueryString?: false | void, + slashesDenoteHost?: boolean + ): UrlWithStringQuery; + declare function parse( + urlStr: string, + parseQueryString?: boolean, + slashesDenoteHost?: boolean + ): Url; + declare function format(urlObj: url$urlObject): string; + declare function resolve(from: string, to: string): string; + declare function domainToASCII(domain: string): string; + declare function domainToUnicode(domain: string): string; + declare function pathToFileURL(path: string): url$urlObject; + declare function fileURLToPath(path: url$urlObject | string): string; + declare class URLSearchParams { + @@iterator(): Iterator<[string, string]>; + + size: number; + + constructor( + init?: + | string + | URLSearchParams + | Array<[string, string]> + | {[string]: string, ...} + ): void; + append(name: string, value: string): void; + delete(name: string, value?: void): void; + entries(): Iterator<[string, string]>; + forEach( + callback: ( + this: This, + value: string, + name: string, + searchParams: URLSearchParams + ) => mixed, + thisArg?: This + ): void; + get(name: string): string | null; + getAll(name: string): string[]; + has(name: string, value?: string): boolean; + keys(): Iterator; + set(name: string, value: string): void; + sort(): void; + values(): Iterator; + toString(): string; + } + declare class URL { + static canParse(url: string, base?: string): boolean; + static createObjectURL(blob: Blob): string; + static createObjectURL(mediaSource: MediaSource): string; + static revokeObjectURL(url: string): void; + constructor(input: string, base?: string | URL): void; + hash: string; + host: string; + hostname: string; + href: string; + +origin: string; + password: string; + pathname: string; + port: string; + protocol: string; + search: string; + +searchParams: URLSearchParams; + username: string; + toString(): string; + toJSON(): string; + } +} + +type util$InspectOptions = { + showHidden?: boolean, + depth?: ?number, + colors?: boolean, + customInspect?: boolean, + ... +}; + +declare type util$ParseArgsOption = + | {| + type: 'boolean', + multiple?: false, + short?: string, + default?: boolean, + |} + | {| + type: 'boolean', + multiple: true, + short?: string, + default?: Array, + |} + | {| + type: 'string', + multiple?: false, + short?: string, + default?: string, + |} + | {| + type: 'string', + multiple: true, + short?: string, + default?: Array, + |}; + +type util$ParseArgsOptionToValue = TOption['type'] extends 'boolean' + ? TOption['multiple'] extends true + ? Array + : boolean + : TOption['type'] extends 'string' + ? TOption['multiple'] extends true + ? Array + : string + : empty; + +type util$ParseArgsOptionsToValues = { + [key in keyof TOptions]: util$ParseArgsOptionToValue<{| + multiple: false, + ...TOptions[key], + |}>, +}; + +type util$ParseArgsToken = + | {| + kind: 'option', + index: number, + name: string, + rawName: string, + value?: string, + inlineValue?: boolean, + |} + | {| + kind: 'positional', + index: number, + value: string, + |} + | {| + kind: 'option-terminator', + index: number, + |}; + +declare module 'util' { + declare function debuglog(section: string): (data: any, ...args: any) => void; + declare function format(format: string, ...placeholders: any): string; + declare function log(string: string): void; + declare function inspect(object: any, options?: util$InspectOptions): string; + declare function isArray(object: any): boolean; + declare function isRegExp(object: any): boolean; + declare function isDate(object: any): boolean; + declare function isError(object: any): boolean; + declare function inherits( + constructor: Function, + superConstructor: Function + ): void; + declare function deprecate(f: Function, string: string): Function; + declare function promisify(f: Function): Function; + declare function callbackify(f: Function): Function; + declare function stripVTControlCharacters(str: string): string; + + declare function parseArgs< + TOptions: {[string]: util$ParseArgsOption} = {||}, + >(config: {| + args?: Array, + options?: TOptions, + strict?: boolean, + allowPositionals?: boolean, + tokens?: false, + |}): {| + values: util$ParseArgsOptionsToValues, + positionals: Array, + |}; + + declare function parseArgs< + TOptions: {[string]: util$ParseArgsOption} = {||}, + >(config: {| + args?: Array, + options?: TOptions, + strict?: boolean, + allowPositionals?: boolean, + tokens: true, + |}): {| + values: util$ParseArgsOptionsToValues, + positionals: Array, + tokens: Array, + |}; + + declare class TextDecoder { + constructor( + encoding?: string, + options: { + fatal?: boolean, + ignoreBOM?: boolean, + ... + } + ): void; + decode( + input?: ArrayBuffer | DataView | $TypedArray, + options?: {stream?: boolean, ...} + ): string; + encoding: string; + fatal: boolean; + ignoreBOM: boolean; + } + + declare class TextEncoder { + constructor(): void; + encode(input?: string): Uint8Array; + encoding: string; + } + + declare var types: { + isAnyArrayBuffer: (value: mixed) => boolean, + isArgumentsObject: (value: mixed) => boolean, + isArrayBuffer: (value: mixed) => boolean, + isAsyncFunction: (value: mixed) => boolean, + isBigInt64Array: (value: mixed) => boolean, + isBigUint64Array: (value: mixed) => boolean, + isBooleanObject: (value: mixed) => boolean, + isBoxedPrimitive: (value: mixed) => boolean, + isDataView: (value: mixed) => boolean, + isDate: (value: mixed) => boolean, + isExternal: (value: mixed) => boolean, + isFloat32Array: (value: mixed) => boolean, + isFloat64Array: (value: mixed) => boolean, + isGeneratorFunction: (value: mixed) => boolean, + isGeneratorObject: (value: mixed) => boolean, + isInt8Array: (value: mixed) => boolean, + isInt16Array: (value: mixed) => boolean, + isInt32Array: (value: mixed) => boolean, + isMap: (value: mixed) => boolean, + isMapIterator: (value: mixed) => boolean, + isModuleNamespaceObject: (value: mixed) => boolean, + isNativeError: (value: mixed) => boolean, + isNumberObject: (value: mixed) => boolean, + isPromise: (value: mixed) => boolean, + isProxy: (value: mixed) => boolean, + isRegExp: (value: mixed) => boolean, + isSet: (value: mixed) => boolean, + isSetIterator: (value: mixed) => boolean, + isSharedArrayBuffer: (value: mixed) => boolean, + isStringObject: (value: mixed) => boolean, + isSymbolObject: (value: mixed) => boolean, + isTypedArray: (value: mixed) => boolean, + isUint8Array: (value: mixed) => boolean, + isUint8ClampedArray: (value: mixed) => boolean, + isUint16Array: (value: mixed) => boolean, + isUint32Array: (value: mixed) => boolean, + isWeakMap: (value: mixed) => boolean, + isWeakSet: (value: mixed) => boolean, + isWebAssemblyCompiledModule: (value: mixed) => boolean, + ... + }; +} + +type vm$ScriptOptions = { + cachedData?: Buffer, + columnOffset?: number, + displayErrors?: boolean, + filename?: string, + lineOffset?: number, + produceCachedData?: boolean, + timeout?: number, + ... +}; + +type vm$CreateContextOptions = { + name?: string, + origin?: string, + codeGeneration?: { + strings?: boolean, + wasm?: boolean, + ... + }, + ... +}; + +type vm$CompileFunctionOptions = { + filename?: string, + lineOffset?: number, + columnOffset?: number, + cachedData?: Buffer, + produceCachedData?: boolean, + parsingContext?: {[key: string]: any, ...}, + contextExtensions?: Array<{[key: string]: any, ...}>, + ... +}; + +declare class vm$Script { + constructor(code: string, options?: vm$ScriptOptions | string): void; + cachedData: ?Buffer; + cachedDataRejected: ?boolean; + cachedDataProduced: ?boolean; + runInContext( + contextifiedSandbox: vm$Context, + options?: vm$ScriptOptions + ): any; + runInNewContext( + sandbox?: {[key: string]: any, ...}, + options?: vm$ScriptOptions + ): any; + runInThisContext(options?: vm$ScriptOptions): any; + createCachedData(): Buffer; +} + +declare class vm$Context {} + +declare module 'vm' { + declare var Script: typeof vm$Script; + declare function createContext( + sandbox?: interface {[key: string]: any}, + options?: vm$CreateContextOptions + ): vm$Context; + declare function isContext(sandbox: {[key: string]: any, ...}): boolean; + declare function runInContext( + code: string, + contextifiedSandbox: vm$Context, + options?: vm$ScriptOptions | string + ): any; + declare function runInDebugContext(code: string): any; + declare function runInNewContext( + code: string, + sandbox?: {[key: string]: any, ...}, + options?: vm$ScriptOptions | string + ): any; + declare function runInThisContext( + code: string, + options?: vm$ScriptOptions | string + ): any; + declare function compileFunction( + code: string, + params: string[], + options: vm$CompileFunctionOptions + ): Function; +} + +type zlib$options = { + flush?: number, + chunkSize?: number, + windowBits?: number, + level?: number, + memLevel?: number, + strategy?: number, + dictionary?: Buffer, + ... +}; + +type zlib$brotliOptions = { + flush?: number, + finishFlush?: number, + chunkSize?: number, + params?: { + [number]: boolean | number, + ... + }, + maxOutputLength?: number, + ... +}; + +type zlib$syncFn = ( + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string, + options?: zlib$options +) => Buffer; + +type zlib$asyncFn = ( + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string, + options?: zlib$options, + callback?: (error: ?Error, result: Buffer) => void +) => void; + +type zlib$brotliSyncFn = ( + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string, + options?: zlib$brotliOptions +) => Buffer; + +type zlib$brotliAsyncFn = ( + buffer: Buffer | $TypedArray | DataView | ArrayBuffer | string, + options?: zlib$brotliOptions, + callback?: (error: ?Error, result: Buffer) => void +) => void; + +// Accessing the constants directly from the module is currently still +// possible but should be considered deprecated. +// ref: https://github.com/nodejs/node/blob/master/doc/api/zlib.md +declare module 'zlib' { + declare var Z_NO_FLUSH: number; + declare var Z_PARTIAL_FLUSH: number; + declare var Z_SYNC_FLUSH: number; + declare var Z_FULL_FLUSH: number; + declare var Z_FINISH: number; + declare var Z_BLOCK: number; + declare var Z_TREES: number; + declare var Z_OK: number; + declare var Z_STREAM_END: number; + declare var Z_NEED_DICT: number; + declare var Z_ERRNO: number; + declare var Z_STREAM_ERROR: number; + declare var Z_DATA_ERROR: number; + declare var Z_MEM_ERROR: number; + declare var Z_BUF_ERROR: number; + declare var Z_VERSION_ERROR: number; + declare var Z_NO_COMPRESSION: number; + declare var Z_BEST_SPEED: number; + declare var Z_BEST_COMPRESSION: number; + declare var Z_DEFAULT_COMPRESSION: number; + declare var Z_FILTERED: number; + declare var Z_HUFFMAN_ONLY: number; + declare var Z_RLE: number; + declare var Z_FIXED: number; + declare var Z_DEFAULT_STRATEGY: number; + declare var Z_BINARY: number; + declare var Z_TEXT: number; + declare var Z_ASCII: number; + declare var Z_UNKNOWN: number; + declare var Z_DEFLATED: number; + declare var Z_NULL: number; + declare var Z_DEFAULT_CHUNK: number; + declare var Z_DEFAULT_LEVEL: number; + declare var Z_DEFAULT_MEMLEVEL: number; + declare var Z_DEFAULT_WINDOWBITS: number; + declare var Z_MAX_CHUNK: number; + declare var Z_MAX_LEVEL: number; + declare var Z_MAX_MEMLEVEL: number; + declare var Z_MAX_WINDOWBITS: number; + declare var Z_MIN_CHUNK: number; + declare var Z_MIN_LEVEL: number; + declare var Z_MIN_MEMLEVEL: number; + declare var Z_MIN_WINDOWBITS: number; + declare var constants: { + Z_NO_FLUSH: number, + Z_PARTIAL_FLUSH: number, + Z_SYNC_FLUSH: number, + Z_FULL_FLUSH: number, + Z_FINISH: number, + Z_BLOCK: number, + Z_TREES: number, + Z_OK: number, + Z_STREAM_END: number, + Z_NEED_DICT: number, + Z_ERRNO: number, + Z_STREAM_ERROR: number, + Z_DATA_ERROR: number, + Z_MEM_ERROR: number, + Z_BUF_ERROR: number, + Z_VERSION_ERROR: number, + Z_NO_COMPRESSION: number, + Z_BEST_SPEED: number, + Z_BEST_COMPRESSION: number, + Z_DEFAULT_COMPRESSION: number, + Z_FILTERED: number, + Z_HUFFMAN_ONLY: number, + Z_RLE: number, + Z_FIXED: number, + Z_DEFAULT_STRATEGY: number, + Z_BINARY: number, + Z_TEXT: number, + Z_ASCII: number, + Z_UNKNOWN: number, + Z_DEFLATED: number, + Z_NULL: number, + Z_DEFAULT_CHUNK: number, + Z_DEFAULT_LEVEL: number, + Z_DEFAULT_MEMLEVEL: number, + Z_DEFAULT_WINDOWBITS: number, + Z_MAX_CHUNK: number, + Z_MAX_LEVEL: number, + Z_MAX_MEMLEVEL: number, + Z_MAX_WINDOWBITS: number, + Z_MIN_CHUNK: number, + Z_MIN_LEVEL: number, + Z_MIN_MEMLEVEL: number, + Z_MIN_WINDOWBITS: number, + + BROTLI_DECODE: number, + BROTLI_ENCODE: number, + BROTLI_OPERATION_PROCESS: number, + BROTLI_OPERATION_FLUSH: number, + BROTLI_OPERATION_FINISH: number, + BROTLI_OPERATION_EMIT_METADATA: number, + BROTLI_PARAM_MODE: number, + BROTLI_MODE_GENERIC: number, + BROTLI_MODE_TEXT: number, + BROTLI_MODE_FONT: number, + BROTLI_DEFAULT_MODE: number, + BROTLI_PARAM_QUALITY: number, + BROTLI_MIN_QUALITY: number, + BROTLI_MAX_QUALITY: number, + BROTLI_DEFAULT_QUALITY: number, + BROTLI_PARAM_LGWIN: number, + BROTLI_MIN_WINDOW_BITS: number, + BROTLI_MAX_WINDOW_BITS: number, + BROTLI_LARGE_MAX_WINDOW_BITS: number, + BROTLI_DEFAULT_WINDOW: number, + BROTLI_PARAM_LGBLOCK: number, + BROTLI_MIN_INPUT_BLOCK_BITS: number, + BROTLI_MAX_INPUT_BLOCK_BITS: number, + BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number, + BROTLI_PARAM_SIZE_HINT: number, + BROTLI_PARAM_LARGE_WINDOW: number, + BROTLI_PARAM_NPOSTFIX: number, + BROTLI_PARAM_NDIRECT: number, + BROTLI_DECODER_RESULT_ERROR: number, + BROTLI_DECODER_RESULT_SUCCESS: number, + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number, + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number, + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number, + BROTLI_DECODER_PARAM_LARGE_WINDOW: number, + BROTLI_DECODER_NO_ERROR: number, + BROTLI_DECODER_SUCCESS: number, + BROTLI_DECODER_NEEDS_MORE_INPUT: number, + BROTLI_DECODER_NEEDS_MORE_OUTPUT: number, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number, + BROTLI_DECODER_ERROR_FORMAT_RESERVED: number, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number, + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number, + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number, + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number, + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number, + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number, + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number, + BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number, + BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number, + BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number, + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number, + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number, + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number, + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number, + BROTLI_DECODER_ERROR_UNREACHABL: number, + ... + }; + declare var codes: { + Z_OK: number, + Z_STREAM_END: number, + Z_NEED_DICT: number, + Z_ERRNO: number, + Z_STREAM_ERROR: number, + Z_DATA_ERROR: number, + Z_MEM_ERROR: number, + Z_BUF_ERROR: number, + Z_VERSION_ERROR: number, + ... + }; + declare class Zlib extends stream$Duplex { + // TODO + } + declare class BrotliCompress extends Zlib {} + declare class BrotliDecompress extends Zlib {} + declare class Deflate extends Zlib {} + declare class Inflate extends Zlib {} + declare class Gzip extends Zlib {} + declare class Gunzip extends Zlib {} + declare class DeflateRaw extends Zlib {} + declare class InflateRaw extends Zlib {} + declare class Unzip extends Zlib {} + declare function createBrotliCompress( + options?: zlib$brotliOptions + ): BrotliCompress; + declare function createBrotliDecompress( + options?: zlib$brotliOptions + ): BrotliDecompress; + declare function createDeflate(options?: zlib$options): Deflate; + declare function createInflate(options?: zlib$options): Inflate; + declare function createDeflateRaw(options?: zlib$options): DeflateRaw; + declare function createInflateRaw(options?: zlib$options): InflateRaw; + declare function createGzip(options?: zlib$options): Gzip; + declare function createGunzip(options?: zlib$options): Gunzip; + declare function createUnzip(options?: zlib$options): Unzip; + declare var brotliCompress: zlib$brotliAsyncFn; + declare var brotliCompressSync: zlib$brotliSyncFn; + declare var brotliDeompress: zlib$brotliAsyncFn; + declare var brotliDecompressSync: zlib$brotliSyncFn; + declare var deflate: zlib$asyncFn; + declare var deflateSync: zlib$syncFn; + declare var gzip: zlib$asyncFn; + declare var gzipSync: zlib$syncFn; + declare var deflateRaw: zlib$asyncFn; + declare var deflateRawSync: zlib$syncFn; + declare var unzip: zlib$asyncFn; + declare var unzipSync: zlib$syncFn; + declare var inflate: zlib$asyncFn; + declare var inflateSync: zlib$syncFn; + declare var gunzip: zlib$asyncFn; + declare var gunzipSync: zlib$syncFn; + declare var inflateRaw: zlib$asyncFn; + declare var inflateRawSync: zlib$syncFn; +} + +declare module 'assert' { + declare class AssertionError extends Error {} + declare type AssertStrict = { + (value: any, message?: string): void, + ok(value: any, message?: string): void, + fail(message?: string | Error): void, + // deprecated since v10.15 + fail(actual: any, expected: any, message: string, operator: string): void, + equal(actual: any, expected: any, message?: string): void, + notEqual(actual: any, expected: any, message?: string): void, + deepEqual(actual: any, expected: any, message?: string): void, + notDeepEqual(actual: any, expected: any, message?: string): void, + throws( + block: Function, + error?: Function | RegExp | ((err: any) => boolean), + message?: string + ): void, + doesNotThrow(block: Function, message?: string): void, + ifError(value: any): void, + AssertionError: typeof AssertionError, + strict: AssertStrict, + ... + }; + declare module.exports: { + (value: any, message?: string): void, + ok(value: any, message?: string): void, + fail(message?: string | Error): void, + // deprecated since v10.15 + fail(actual: any, expected: any, message: string, operator: string): void, + equal(actual: any, expected: any, message?: string): void, + notEqual(actual: any, expected: any, message?: string): void, + deepEqual(actual: any, expected: any, message?: string): void, + notDeepEqual(actual: any, expected: any, message?: string): void, + strictEqual(actual: any, expected: any, message?: string): void, + notStrictEqual(actual: any, expected: any, message?: string): void, + deepStrictEqual(actual: any, expected: any, message?: string): void, + notDeepStrictEqual(actual: any, expected: any, message?: string): void, + throws( + block: Function, + error?: Function | RegExp | ((err: any) => boolean), + message?: string + ): void, + doesNotThrow(block: Function, message?: string): void, + ifError(value: any): void, + AssertionError: typeof AssertionError, + strict: AssertStrict, + ... + }; +} + +type HeapCodeStatistics = { + code_and_metadata_size: number, + bytecode_and_metadata_size: number, + external_script_source_size: number, + ... +}; + +type HeapStatistics = { + total_heap_size: number, + total_heap_size_executable: number, + total_physical_size: number, + total_available_size: number, + used_heap_size: number, + heap_size_limit: number, + malloced_memory: number, + peak_malloced_memory: number, + does_zap_garbage: 0 | 1, + number_of_native_contexts: number, + number_of_detached_contexts: number, + ... +}; + +type HeapSpaceStatistics = { + space_name: string, + space_size: number, + space_used_size: number, + space_available_size: number, + physical_space_size: number, + ... +}; + +// Adapted from DefinitelyTyped for Node v14: +// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/dea4d99dc302a0b0a25270e46e72c1fe9b741a17/types/node/v14/v8.d.ts +declare module 'v8' { + /** + * Returns an integer representing a "version tag" derived from the V8 version, command line flags and detected CPU features. + * This is useful for determining whether a vm.Script cachedData buffer is compatible with this instance of V8. + */ + declare function cachedDataVersionTag(): number; + + /** + * Generates a snapshot of the current V8 heap and returns a Readable + * Stream that may be used to read the JSON serialized representation. + * This conversation was marked as resolved by joyeecheung + * This JSON stream format is intended to be used with tools such as + * Chrome DevTools. The JSON schema is undocumented and specific to the + * V8 engine, and may change from one version of V8 to the next. + */ + declare function getHeapSnapshot(): stream$Readable; + + /** + * + * @param fileName The file path where the V8 heap snapshot is to be + * saved. If not specified, a file name with the pattern + * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be + * generated, where `{pid}` will be the PID of the Node.js process, + * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from + * the main Node.js thread or the id of a worker thread. + */ + declare function writeHeapSnapshot(fileName?: string): string; + + declare function getHeapCodeStatistics(): HeapCodeStatistics; + + declare function getHeapStatistics(): HeapStatistics; + declare function getHeapSpaceStatistics(): Array; + declare function setFlagsFromString(flags: string): void; + + declare class Serializer { + constructor(): void; + + /** + * Writes out a header, which includes the serialization format version. + */ + writeHeader(): void; + + /** + * Serializes a JavaScript value and adds the serialized representation to the internal buffer. + * This throws an error if value cannot be serialized. + */ + writeValue(val: any): boolean; + + /** + * Returns the stored internal buffer. + * This serializer should not be used once the buffer is released. + * Calling this method results in undefined behavior if a previous write has failed. + */ + releaseBuffer(): Buffer; + + /** + * Marks an ArrayBuffer as having its contents transferred out of band.\ + * Pass the corresponding ArrayBuffer in the deserializing context to deserializer.transferArrayBuffer(). + */ + transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void; + + /** + * Write a raw 32-bit unsigned integer. + */ + writeUint32(value: number): void; + + /** + * Write a raw 64-bit unsigned integer, split into high and low 32-bit parts. + */ + writeUint64(hi: number, lo: number): void; + + /** + * Write a JS number value. + */ + writeDouble(value: number): void; + + /** + * Write raw bytes into the serializer’s internal buffer. + * The deserializer will require a way to compute the length of the buffer. + */ + writeRawBytes(buffer: Buffer | $TypedArray | DataView): void; + } + + /** + * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects, + * and only stores the part of their underlying `ArrayBuffers` that they are referring to. + */ + declare class DefaultSerializer extends Serializer {} + + declare class Deserializer { + constructor(data: Buffer | $TypedArray | DataView): void; + + /** + * Reads and validates a header (including the format version). + * May, for example, reject an invalid or unsupported wire format. + * In that case, an Error is thrown. + */ + readHeader(): boolean; + + /** + * Deserializes a JavaScript value from the buffer and returns it. + */ + readValue(): any; + + /** + * Marks an ArrayBuffer as having its contents transferred out of band. + * Pass the corresponding `ArrayBuffer` in the serializing context to serializer.transferArrayBuffer() + * (or return the id from serializer._getSharedArrayBufferId() in the case of SharedArrayBuffers). + */ + transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void; + + /** + * Reads the underlying wire format version. + * Likely mostly to be useful to legacy code reading old wire format versions. + * May not be called before .readHeader(). + */ + getWireFormatVersion(): number; + + /** + * Read a raw 32-bit unsigned integer and return it. + */ + readUint32(): number; + + /** + * Read a raw 64-bit unsigned integer and return it as an array [hi, lo] with two 32-bit unsigned integer entries. + */ + readUint64(): [number, number]; + + /** + * Read a JS number value. + */ + readDouble(): number; + + /** + * Read raw bytes from the deserializer’s internal buffer. + * The length parameter must correspond to the length of the buffer that was passed to serializer.writeRawBytes(). + */ + readRawBytes(length: number): Buffer; + } + + /** + * A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects, + * and only stores the part of their underlying `ArrayBuffers` that they are referring to. + */ + declare class DefaultDeserializer extends Deserializer {} + + /** + * Uses a `DefaultSerializer` to serialize value into a buffer. + */ + declare function serialize(value: any): Buffer; + + /** + * Uses a `DefaultDeserializer` with default options to read a JS value from a buffer. + */ + declare function deserialize(data: Buffer | $TypedArray | DataView): any; +} + +type repl$DefineCommandOptions = (...args: Array) => void | { + action: (...args: Array) => void, + help?: string, + ... +}; + +declare class $SymbolReplModeMagic mixins Symbol {} +declare class $SymbolReplModeSloppy mixins Symbol {} +declare class $SymbolReplModeStrict mixins Symbol {} + +declare module 'repl' { + declare var REPL_MODE_MAGIC: $SymbolReplModeMagic; + declare var REPL_MODE_SLOPPY: $SymbolReplModeSloppy; + declare var REPL_MODE_STRICT: $SymbolReplModeStrict; + + declare class REPLServer extends readline$Interface { + context: vm$Context; + defineCommand(command: string, options: repl$DefineCommandOptions): void; + displayPrompt(preserveCursor?: boolean): void; + } + + declare function start(prompt: string): REPLServer; + declare function start(options: { + prompt?: string, + input?: stream$Readable, + output?: stream$Writable, + terminal?: boolean, + eval?: Function, + useColors?: boolean, + useGlobal?: boolean, + ignoreUndefined?: boolean, + writer?: (object: any, options?: util$InspectOptions) => string, + completer?: readline$InterfaceCompleter, + replMode?: + | $SymbolReplModeMagic + | $SymbolReplModeSloppy + | $SymbolReplModeStrict, + breakEvalOnSigint?: boolean, + ... + }): REPLServer; + + declare class Recoverable extends SyntaxError { + constructor(err: Error): void; + } +} + +declare module 'inspector' { + declare function open(port?: number, host?: string, wait?: boolean): void; + + declare function close(): void; + declare function url(): string | void; + declare var console: Object; + declare function waitForDebugger(): void; + + declare class Session extends events$EventEmitter { + constructor(): void; + connect(): void; + connectToMainThread(): void; + disconnect(): void; + post(method: string, params?: Object, callback?: Function): void; + } +} + +/* globals: https://nodejs.org/api/globals.html */ + +type process$CPUUsage = { + user: number, + system: number, + ... +}; + +declare class Process extends events$EventEmitter { + abort(): void; + allowedNodeEnvironmentFlags: Set; + arch: string; + argv: Array; + chdir(directory: string): void; + config: Object; + connected: boolean; + cpuUsage(previousValue?: process$CPUUsage): process$CPUUsage; + cwd(): string; + disconnect?: () => void; + domain?: domain$Domain; + env: {[key: string]: string | void, ...}; + emitWarning(warning: string | Error): void; + emitWarning( + warning: string, + typeOrCtor: string | ((...empty) => mixed) + ): void; + emitWarning( + warning: string, + type: string, + codeOrCtor: string | ((...empty) => mixed) + ): void; + emitWarning( + warning: string, + type: string, + code: string, + ctor?: (...empty) => mixed + ): void; + execArgv: Array; + execPath: string; + exit(code?: number): empty; + exitCode?: number; + getegid?: () => number; + geteuid?: () => number; + getgid?: () => number; + getgroups?: () => Array; + getuid?: () => number; + hrtime: { + (time?: [number, number]): [number, number], + bigint: () => bigint, + ... + }; + initgroups?: (user: number | string, extra_group: number | string) => void; + kill(pid: number, signal?: string | number): void; + mainModule: Object; + memoryUsage(): { + arrayBuffers: number, + rss: number, + heapTotal: number, + heapUsed: number, + external: number, + ... + }; + nextTick: (cb: (...T) => mixed, ...T) => void; + pid: number; + platform: string; + release: { + name: string, + lts?: string, + sourceUrl: string, + headersUrl: string, + libUrl: string, + ... + }; + send?: ( + message: any, + sendHandleOrCallback?: net$Socket | net$Server | Function, + callback?: Function + ) => void; + setegid?: (id: number | string) => void; + seteuid?: (id: number | string) => void; + setgid?: (id: number | string) => void; + setgroups?: (groups: Array) => void; + setuid?: (id: number | string) => void; + stderr: stream$Writable | tty$WriteStream; + stdin: stream$Readable | tty$ReadStream; + stdout: stream$Writable | tty$WriteStream; + title: string; + umask(mask?: number): number; + uptime(): number; + version: string; + versions: { + [key: string]: ?string, + node: string, + v8: string, + ... + }; +} +declare var process: Process; + +declare var __filename: string; +declare var __dirname: string; + +declare function setImmediate( + callback: (...args: Array) => mixed, + ...args: Array +): Object; +declare function clearImmediate(immediateObject: any): Object; + +// https://nodejs.org/api/esm.html#node-imports + +declare module 'node:assert' { + declare module.exports: $Exports<'assert'>; +} + +declare module 'node:assert/strict' { + declare module.exports: $Exports<'assert'>['strict']; +} + +declare module 'node:events' { + declare module.exports: $Exports<'events'>; +} + +declare module 'node:fs' { + declare module.exports: $Exports<'fs'>; +} + +declare module 'node:os' { + declare module.exports: $Exports<'os'>; +} + +declare module 'fs/promises' { + declare module.exports: $Exports<'fs'>['promises']; +} + +declare module 'node:fs/promises' { + declare module.exports: $Exports<'fs'>['promises']; +} + +declare module 'node:path' { + declare module.exports: $Exports<'path'>; +} + +declare module 'process' { + declare module.exports: Process; +} + +declare module 'node:process' { + declare module.exports: $Exports<'process'>; +} + +declare module 'node:util' { + declare module.exports: $Exports<'util'>; +} + +declare module 'node:url' { + declare module.exports: $Exports<'url'>; +} + +declare module 'worker_threads' { + declare var isMainThread: boolean; + declare var parentPort: null | MessagePort; + declare var threadId: number; + declare var workerData: any; + + declare class MessageChannel { + +port1: MessagePort; + +port2: MessagePort; + } + + declare class MessagePort extends events$EventEmitter { + close(): void; + postMessage( + value: any, + transferList?: Array + ): void; + ref(): void; + unref(): void; + start(): void; + + addListener(event: 'close', listener: () => void): this; + addListener(event: 'message', listener: (value: any) => void): this; + addListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + emit(event: 'close'): boolean; + emit(event: 'message', value: any): boolean; + emit(event: string | Symbol, ...args: any[]): boolean; + + on(event: 'close', listener: () => void): this; + on(event: 'message', listener: (value: any) => void): this; + on(event: string | Symbol, listener: (...args: any[]) => void): this; + + once(event: 'close', listener: () => void): this; + once(event: 'message', listener: (value: any) => void): this; + once(event: string | Symbol, listener: (...args: any[]) => void): this; + + prependListener(event: 'close', listener: () => void): this; + prependListener(event: 'message', listener: (value: any) => void): this; + prependListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + prependOnceListener(event: 'close', listener: () => void): this; + prependOnceListener(event: 'message', listener: (value: any) => void): this; + prependOnceListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + removeListener(event: 'close', listener: () => void): this; + removeListener(event: 'message', listener: (value: any) => void): this; + removeListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + off(event: 'close', listener: () => void): this; + off(event: 'message', listener: (value: any) => void): this; + off(event: string | Symbol, listener: (...args: any[]) => void): this; + } + + declare type WorkerOptions = {| + env?: Object, + eval?: boolean, + workerData?: any, + stdin?: boolean, + stdout?: boolean, + stderr?: boolean, + execArgv?: string[], + |}; + + declare class Worker extends events$EventEmitter { + +stdin: stream$Writable | null; + +stdout: stream$Readable; + +stderr: stream$Readable; + +threadId: number; + + constructor(filename: string, options?: WorkerOptions): void; + + postMessage( + value: any, + transferList?: Array + ): void; + ref(): void; + unref(): void; + terminate(callback?: (err: Error, exitCode: number) => void): void; + /** + * Transfer a `MessagePort` to a different `vm` Context. The original `port` + * object will be rendered unusable, and the returned `MessagePort` instance will + * take its place. + * + * The returned `MessagePort` will be an object in the target context, and will + * inherit from its global `Object` class. Objects passed to the + * `port.onmessage()` listener will also be created in the target context + * and inherit from its global `Object` class. + * + * However, the created `MessagePort` will no longer inherit from + * `EventEmitter`, and only `port.onmessage()` can be used to receive + * events using it. + */ + moveMessagePortToContext( + port: MessagePort, + context: vm$Context + ): MessagePort; + + addListener(event: 'error', listener: (err: Error) => void): this; + addListener(event: 'exit', listener: (exitCode: number) => void): this; + addListener(event: 'message', listener: (value: any) => void): this; + addListener(event: 'online', listener: () => void): this; + addListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + emit(event: 'error', err: Error): boolean; + emit(event: 'exit', exitCode: number): boolean; + emit(event: 'message', value: any): boolean; + emit(event: 'online'): boolean; + emit(event: string | Symbol, ...args: any[]): boolean; + + on(event: 'error', listener: (err: Error) => void): this; + on(event: 'exit', listener: (exitCode: number) => void): this; + on(event: 'message', listener: (value: any) => void): this; + on(event: 'online', listener: () => void): this; + on(event: string | Symbol, listener: (...args: any[]) => void): this; + + once(event: 'error', listener: (err: Error) => void): this; + once(event: 'exit', listener: (exitCode: number) => void): this; + once(event: 'message', listener: (value: any) => void): this; + once(event: 'online', listener: () => void): this; + once(event: string | Symbol, listener: (...args: any[]) => void): this; + + prependListener(event: 'error', listener: (err: Error) => void): this; + prependListener(event: 'exit', listener: (exitCode: number) => void): this; + prependListener(event: 'message', listener: (value: any) => void): this; + prependListener(event: 'online', listener: () => void): this; + prependListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + prependOnceListener(event: 'error', listener: (err: Error) => void): this; + prependOnceListener( + event: 'exit', + listener: (exitCode: number) => void + ): this; + prependOnceListener(event: 'message', listener: (value: any) => void): this; + prependOnceListener(event: 'online', listener: () => void): this; + prependOnceListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + removeListener(event: 'error', listener: (err: Error) => void): this; + removeListener(event: 'exit', listener: (exitCode: number) => void): this; + removeListener(event: 'message', listener: (value: any) => void): this; + removeListener(event: 'online', listener: () => void): this; + removeListener( + event: string | Symbol, + listener: (...args: any[]) => void + ): this; + + off(event: 'error', listener: (err: Error) => void): this; + off(event: 'exit', listener: (exitCode: number) => void): this; + off(event: 'message', listener: (value: any) => void): this; + off(event: 'online', listener: () => void): this; + off(event: string | Symbol, listener: (...args: any[]) => void): this; + } +} + +declare module 'node:worker_threads' { + declare module.exports: $Exports<'worker_threads'>; +} diff --git a/flow-typed/environments/serviceworkers.js b/flow-typed/environments/serviceworkers.js new file mode 100644 index 0000000000000..86479648e2e88 --- /dev/null +++ b/flow-typed/environments/serviceworkers.js @@ -0,0 +1,248 @@ +// flow-typed signature: f6bda44505d6258bae702a65ee2878f2 +// flow-typed version: 840509ea9d/serviceworkers/flow_>=v0.261.x + +type FrameType = 'auxiliary' | 'top-level' | 'nested' | 'none'; +type VisibilityState = 'hidden' | 'visible' | 'prerender' | 'unloaded'; + +declare class WindowClient extends Client { + visibilityState: VisibilityState; + focused: boolean; + focus(): Promise; + navigate(url: string): Promise; +} + +declare class Client { + id: string; + reserved: boolean; + url: string; + frameType: FrameType; + postMessage(message: any, transfer?: Iterator | Array): void; +} + +declare class ExtendableEvent extends Event { + waitUntil(f: Promise): void; +} + +type NotificationEvent$Init = { + ...Event$Init, + notification: Notification, + action?: string, + ... +}; + +declare class NotificationEvent extends ExtendableEvent { + constructor(type: string, eventInitDict?: NotificationEvent$Init): void; + +notification: Notification; + +action: string; +} + +type ForeignFetchOptions = { + scopes: Iterator, + origins: Iterator, + ... +}; + +declare class InstallEvent extends ExtendableEvent { + registerForeignFetch(options: ForeignFetchOptions): void; +} + +declare class FetchEvent extends ExtendableEvent { + request: Request; + clientId: string; + isReload: boolean; + respondWith(response: Response | Promise): void; + preloadResponse: Promise; +} + +type ClientType = 'window' | 'worker' | 'sharedworker' | 'all'; +type ClientQueryOptions = { + includeUncontrolled?: boolean, + includeReserved?: boolean, + type?: ClientType, + ... +}; + +declare class Clients { + get(id: string): Promise; + matchAll(options?: ClientQueryOptions): Promise>; + openWindow(url: string): Promise; + claim(): Promise; +} + +type ServiceWorkerState = + | 'installing' + | 'installed' + | 'activating' + | 'activated' + | 'redundant'; + +declare class ServiceWorker extends EventTarget { + scriptURL: string; + state: ServiceWorkerState; + + postMessage(message: any, transfer?: Iterator): void; + + onstatechange?: EventHandler; +} + +declare class NavigationPreloadState { + enabled: boolean; + headerValue: string; +} + +declare class NavigationPreloadManager { + enable: Promise; + disable: Promise; + setHeaderValue(value: string): Promise; + getState: Promise; +} + +type PushSubscriptionOptions = { + userVisibleOnly?: boolean, + applicationServerKey?: string | ArrayBuffer | $ArrayBufferView, + ... +}; + +declare class PushSubscriptionJSON { + endpoint: string; + expirationTime: number | null; + keys: {[string]: string, ...}; +} + +declare class PushSubscription { + +endpoint: string; + +expirationTime: number | null; + +options: PushSubscriptionOptions; + getKey(name: string): ArrayBuffer | null; + toJSON(): PushSubscriptionJSON; + unsubscribe(): Promise; +} + +declare class PushManager { + +supportedContentEncodings: Array; + subscribe(options?: PushSubscriptionOptions): Promise; + getSubscription(): Promise; + permissionState( + options?: PushSubscriptionOptions + ): Promise<'granted' | 'denied' | 'prompt'>; +} + +type ServiceWorkerUpdateViaCache = 'imports' | 'all' | 'none'; + +type GetNotificationOptions = { + tag?: string, + ... +}; + +declare class ServiceWorkerRegistration extends EventTarget { + +installing: ?ServiceWorker; + +waiting: ?ServiceWorker; + +active: ?ServiceWorker; + +navigationPreload: NavigationPreloadManager; + +scope: string; + +updateViaCache: ServiceWorkerUpdateViaCache; + +pushManager: PushManager; + + getNotifications?: ( + filter?: GetNotificationOptions + ) => Promise<$ReadOnlyArray>; + showNotification?: ( + title: string, + options?: NotificationOptions + ) => Promise; + update(): Promise; + unregister(): Promise; + + onupdatefound?: EventHandler; +} + +type WorkerType = 'classic' | 'module'; + +type RegistrationOptions = { + scope?: string, + type?: WorkerType, + updateViaCache?: ServiceWorkerUpdateViaCache, + ... +}; + +declare class ServiceWorkerContainer extends EventTarget { + +controller: ?ServiceWorker; + +ready: Promise; + + getRegistration( + clientURL?: string + ): Promise; + getRegistrations(): Promise>; + register( + scriptURL: string | TrustedScriptURL, + options?: RegistrationOptions + ): Promise; + startMessages(): void; + + oncontrollerchange?: EventHandler; + onmessage?: EventHandler; + onmessageerror?: EventHandler; +} + +/** + * This feature has been removed from the Web standards. + */ +declare class ServiceWorkerMessageEvent extends Event { + data: any; + lastEventId: string; + origin: string; + ports: Array; + source: ?(ServiceWorker | MessagePort); +} + +declare class ExtendableMessageEvent extends ExtendableEvent { + data: any; + lastEventId: string; + origin: string; + ports: Array; + source: ?(ServiceWorker | MessagePort); +} + +type CacheQueryOptions = { + ignoreSearch?: boolean, + ignoreMethod?: boolean, + ignoreVary?: boolean, + cacheName?: string, + ... +}; + +declare class Cache { + match(request: RequestInfo, options?: CacheQueryOptions): Promise; + matchAll( + request: RequestInfo, + options?: CacheQueryOptions + ): Promise>; + add(request: RequestInfo): Promise; + addAll(requests: Array): Promise; + put(request: RequestInfo, response: Response): Promise; + delete(request: RequestInfo, options?: CacheQueryOptions): Promise; + keys( + request?: RequestInfo, + options?: CacheQueryOptions + ): Promise>; +} + +declare class CacheStorage { + match(request: RequestInfo, options?: CacheQueryOptions): Promise; + has(cacheName: string): Promise; + open(cacheName: string): Promise; + delete(cacheName: string): Promise; + keys(): Promise>; +} + +// Service worker global scope +// https://www.w3.org/TR/service-workers/#service-worker-global-scope +declare var clients: Clients; +declare var caches: CacheStorage; +declare var registration: ServiceWorkerRegistration; +declare function skipWaiting(): Promise; +declare var onactivate: ?EventHandler; +declare var oninstall: ?EventHandler; +declare var onfetch: ?EventHandler; +declare var onforeignfetch: ?EventHandler; +declare var onmessage: ?EventHandler; diff --git a/flow-typed/environments/streams.js b/flow-typed/environments/streams.js new file mode 100644 index 0000000000000..17bfae29e612c --- /dev/null +++ b/flow-typed/environments/streams.js @@ -0,0 +1,136 @@ +// flow-typed signature: e6e6768618776352dd676f63502aea4d +// flow-typed version: 40e7dfcbd5/streams/flow_>=v0.261.x + +type TextEncodeOptions = {options?: boolean, ...}; + +declare class ReadableStreamController { + constructor( + stream: ReadableStream, + underlyingSource: UnderlyingSource, + size: number, + highWaterMark: number + ): void; + + desiredSize: number; + + close(): void; + enqueue(chunk: any): void; + error(error: Error): void; +} + +declare class ReadableStreamBYOBRequest { + constructor(controller: ReadableStreamController, view: $TypedArray): void; + + view: $TypedArray; + + respond(bytesWritten: number): ?any; + respondWithNewView(view: $TypedArray): ?any; +} + +declare class ReadableByteStreamController extends ReadableStreamController { + constructor( + stream: ReadableStream, + underlyingSource: UnderlyingSource, + highWaterMark: number + ): void; + + byobRequest: ReadableStreamBYOBRequest; +} + +declare class ReadableStreamReader { + constructor(stream: ReadableStream): void; + + closed: boolean; + + cancel(reason: string): void; + read(): Promise<{ + value: ?any, + done: boolean, + ... + }>; + releaseLock(): void; +} + +declare interface UnderlyingSource { + autoAllocateChunkSize?: number; + type?: string; + + start?: (controller: ReadableStreamController) => ?Promise; + pull?: (controller: ReadableStreamController) => ?Promise; + cancel?: (reason: string) => ?Promise; +} + +declare class TransformStream { + readable: ReadableStream; + writable: WritableStream; +} + +interface PipeThroughTransformStream { + readable: ReadableStream; + writable: WritableStream; +} + +type PipeToOptions = { + preventClose?: boolean, + preventAbort?: boolean, + preventCancel?: boolean, + ... +}; + +type QueuingStrategy = { + highWaterMark: number, + size(chunk: ?any): number, + ... +}; + +declare class ReadableStream { + constructor( + underlyingSource: ?UnderlyingSource, + queuingStrategy: ?QueuingStrategy + ): void; + + locked: boolean; + + cancel(reason: string): void; + getReader(): ReadableStreamReader; + pipeThrough(transform: PipeThroughTransformStream, options: ?any): void; + pipeTo(dest: WritableStream, options: ?PipeToOptions): Promise; + tee(): [ReadableStream, ReadableStream]; +} + +declare interface WritableStreamController { + error(error: Error): void; +} + +declare interface UnderlyingSink { + autoAllocateChunkSize?: number; + type?: string; + + abort?: (reason: string) => ?Promise; + close?: (controller: WritableStreamController) => ?Promise; + start?: (controller: WritableStreamController) => ?Promise; + write?: (chunk: any, controller: WritableStreamController) => ?Promise; +} + +declare interface WritableStreamWriter { + closed: Promise; + desiredSize?: number; + ready: Promise; + + abort(reason: string): ?Promise; + close(): Promise; + releaseLock(): void; + write(chunk: any): Promise; +} + +declare class WritableStream { + constructor( + underlyingSink: ?UnderlyingSink, + queuingStrategy: QueuingStrategy + ): void; + + locked: boolean; + + abort(reason: string): void; + getWriter(): WritableStreamWriter; +} diff --git a/flow-typed/environments/web-animations.js b/flow-typed/environments/web-animations.js new file mode 100644 index 0000000000000..ac059631f7c35 --- /dev/null +++ b/flow-typed/environments/web-animations.js @@ -0,0 +1,193 @@ +// flow-typed signature: 4631a74b6a0e6a1b4de2ba8c7bb141d6 +// flow-typed version: 3e51657e95/web-animations/flow_>=v0.261.x + +// https://www.w3.org/TR/web-animations-1/ + +type AnimationPlayState = 'idle' | 'running' | 'paused' | 'finished'; + +type AnimationReplaceState = 'active' | 'removed' | 'persisted'; + +type CompositeOperation = 'replace' | 'add' | 'accumulate'; + +type CompositeOperationOrAuto = 'replace' | 'add' | 'accumulate' | 'auto'; + +type FillMode = 'none' | 'forwards' | 'backwards' | 'both' | 'auto'; + +// This is actually web-animations-2 +type IterationCompositeOperation = 'replace' | 'accumulate'; + +type PlaybackDirection = + | 'normal' + | 'reverse' + | 'alternate' + | 'alternate-reverse'; + +type AnimationPlaybackEvent$Init = Event$Init & { + currentTime?: number | null, + timelineTime?: number | null, + ... +}; + +type BaseComputedKeyframe = {| + composite: CompositeOperationOrAuto, + computedOffset: number, + easing: string, + offset: number | null, +|}; + +type BaseKeyframe = {| + composite: CompositeOperationOrAuto, + easing: string, + offset: number | null, +|}; + +type BasePropertyIndexedKeyframe = {| + composite: CompositeOperationOrAuto | Array, + easing: string | Array, + offset: number | null | Array, +|}; + +type ComputedEffectTiming = {| + ...EffectTiming, + currentIteration: number | null, + progress: number | null, +|}; + +type ComputedKeyframe = { + composite: CompositeOperationOrAuto, + computedOffset: number, + easing: string, + offset: number | null, + [property: string]: string | number | null | void, + ... +}; + +type DocumentTimelineOptions = {| + originTime: number, +|}; + +type EffectTiming = {| + direction: PlaybackDirection, + easing: string, + fill: FillMode, + iterations: number, + iterationStart: number, +|}; + +type GetAnimationsOptions = {| + pseudoElement: string | null, + subtree: boolean, +|}; + +type KeyframeAnimationOptions = {| + ...KeyframeEffectOptions, + id: string, + timeline: AnimationTimeline | null, +|}; + +type KeyframeEffectOptions = {| + ...EffectTiming, + composite: CompositeOperation, + pseudoElement: string | null, +|}; + +type Keyframe = { + composite?: CompositeOperationOrAuto, + easing?: string, + offset?: number | null, + [property: string]: string | number | null | void, + ... +}; + +type OptionalEffectTiming = Partial; + +type PropertyIndexedKeyframes = { + composite?: CompositeOperationOrAuto | CompositeOperationOrAuto[], + easing?: string | string[], + offset?: number | (number | null)[], + [property: string]: + | string + | string[] + | number + | null + | (number | null)[] + | void, + ... +}; + +declare class Animation extends EventTarget { + constructor( + effect?: AnimationEffect | null, + timeline?: AnimationTimeline | null + ): void; + + id: string; + effect: AnimationEffect | null; + timeline: AnimationTimeline | null; + startTime: number | null; + currentTime: number | null; + playbackRate: number; + +playState: AnimationPlayState; + +replaceState: AnimationReplaceState; + +pending: boolean; + +ready: Promise; + +finished: Promise; + onfinish: ?(ev: AnimationPlaybackEvent) => mixed; + oncancel: ?(ev: AnimationPlaybackEvent) => mixed; + onremove: ?(ev: AnimationPlaybackEvent) => mixed; + cancel(): void; + finish(): void; + play(): void; + pause(): void; + updatePlaybackRate(playbackRate: number): void; + reverse(): void; + persist(): void; + commitStyles(): void; +} + +declare class AnimationEffect { + getTiming(): EffectTiming; + getComputedTiming(): ComputedEffectTiming; + updateTiming(timing?: OptionalEffectTiming): void; +} + +declare class AnimationPlaybackEvent extends Event { + constructor( + type: string, + animationEventInitDict?: AnimationPlaybackEvent$Init + ): void; + +currentTime: number | null; + +timelineTime: number | null; +} + +declare class AnimationTimeline { + +currentTime: number | null; +} + +declare class DocumentTimeline extends AnimationTimeline { + constructor(options?: DocumentTimelineOptions): void; +} + +declare class KeyframeEffect extends AnimationEffect { + constructor( + target: Element | null, + keyframes: Keyframe[] | PropertyIndexedKeyframes | null, + options?: number | KeyframeEffectOptions + ): void; + constructor(source: KeyframeEffect): void; + + target: Element | null; + composite: CompositeOperation; + // This is actually web-animations-2 + iterationComposite: IterationCompositeOperation; + getKeyframes(): ComputedKeyframe[]; + setKeyframes(keyframes: Keyframe[] | PropertyIndexedKeyframes | null): void; +} + +declare class mixin$Animatable { + animate( + keyframes: Keyframe[] | PropertyIndexedKeyframes | null, + options?: number | KeyframeAnimationOptions + ): Animation; + getAnimations(options?: GetAnimationsOptions): Array; +} diff --git a/flow-typed/npm/error-stack-parser_v2.x.x.js b/flow-typed/npm/error-stack-parser_v2.x.x.js new file mode 100644 index 0000000000000..d23b837af2524 --- /dev/null +++ b/flow-typed/npm/error-stack-parser_v2.x.x.js @@ -0,0 +1,60 @@ +// flow-typed signature: 132e48034ef4756600e1d98681a166b5 +// flow-typed version: c6154227d1/error-stack-parser_v2.x.x/flow_>=v0.104.x + +declare module 'error-stack-parser' { + declare interface StackFrame { + constructor(object: StackFrame): StackFrame; + + isConstructor?: boolean; + getIsConstructor(): boolean; + setIsConstructor(): void; + + isEval?: boolean; + getIsEval(): boolean; + setIsEval(): void; + + isNative?: boolean; + getIsNative(): boolean; + setIsNative(): void; + + isTopLevel?: boolean; + getIsTopLevel(): boolean; + setIsTopLevel(): void; + + columnNumber?: number; + getColumnNumber(): number; + setColumnNumber(): void; + + lineNumber?: number; + getLineNumber(): number; + setLineNumber(): void; + + fileName?: string; + getFileName(): string; + setFileName(): void; + + functionName?: string; + getFunctionName(): string; + setFunctionName(): void; + + source?: string; + getSource(): string; + setSource(): void; + + args?: any[]; + getArgs(): any[]; + setArgs(): void; + + evalOrigin?: StackFrame; + getEvalOrigin(): StackFrame; + setEvalOrigin(): void; + + toString(): string; + } + + declare class ErrorStackParser { + parse(error: Error): Array; + } + + declare module.exports: ErrorStackParser; +} diff --git a/flow-typed/npm/minimist_v1.x.x.js b/flow-typed/npm/minimist_v1.x.x.js new file mode 100644 index 0000000000000..9da29ffe60c05 --- /dev/null +++ b/flow-typed/npm/minimist_v1.x.x.js @@ -0,0 +1,27 @@ +// flow-typed signature: d48da8db828529253fc20b80747846ea +// flow-typed version: c6154227d1/minimist_v1.x.x/flow_>=v0.104.x + +declare module 'minimist' { + declare type minimistOptions = { + string?: string | Array, + boolean?: boolean | string | Array, + alias?: {[arg: string]: string | Array, ...}, + default?: {[arg: string]: any, ...}, + stopEarly?: boolean, + // TODO: Strings as keys don't work... + // '--'? boolean, + unknown?: (param: string) => boolean, + ... + }; + + declare type minimistOutput = { + [flag: string]: string | boolean, + _: Array, + ... + }; + + declare module.exports: ( + argv: Array, + opts?: minimistOptions + ) => minimistOutput; +} diff --git a/package.json b/package.json index b73af395bae25..2a83ef95f2090 100644 --- a/package.json +++ b/package.json @@ -74,8 +74,9 @@ "eslint-plugin-react-internal": "link:./scripts/eslint-rules", "fbjs-scripts": "^3.0.1", "filesize": "^6.0.1", - "flow-bin": "^0.261", - "flow-remove-types": "^2.261", + "flow-bin": "^0.263", + "flow-remove-types": "^2.263", + "flow-typed": "^4.1.1", "glob": "^7.1.6", "glob-stream": "^6.1.0", "google-closure-compiler": "^20230206.0.0", @@ -126,6 +127,7 @@ "build-for-devtools-prod": "yarn build-for-devtools --type=NODE_PROD", "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", "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", + "flow-typed-install": "yarn flow-typed install --skip --skipFlowRestart --ignore-deps=dev", "linc": "node ./scripts/tasks/linc.js", "lint": "node ./scripts/tasks/eslint.js", "lint-build": "node ./scripts/rollup/validate/index.js", diff --git a/packages/react-devtools-shared/src/backend/views/utils.js b/packages/react-devtools-shared/src/backend/views/utils.js index 595b87c481874..a73c8094edb9f 100644 --- a/packages/react-devtools-shared/src/backend/views/utils.js +++ b/packages/react-devtools-shared/src/backend/views/utils.js @@ -40,6 +40,7 @@ export function getOwnerIframe(node: HTMLElement): HTMLElement | null { // offset added to compensate for its border. export function getBoundingClientRectWithBorderOffset(node: HTMLElement): Rect { const dimensions = getElementDimensions(node); + // $FlowFixMe[incompatible-variance] return mergeRectOffsets([ node.getBoundingClientRect(), { @@ -102,8 +103,10 @@ export function getNestedBoundingClientRect( } } + // $FlowFixMe[incompatible-variance] return mergeRectOffsets(rects); } else { + // $FlowFixMe[incompatible-variance] return node.getBoundingClientRect(); } } diff --git a/packages/react-devtools-shared/src/devtools/views/Components/Components.js b/packages/react-devtools-shared/src/devtools/views/Components/Components.js index b6278c2db993d..cfa73bbad8032 100644 --- a/packages/react-devtools-shared/src/devtools/views/Components/Components.js +++ b/packages/react-devtools-shared/src/devtools/views/Components/Components.js @@ -24,6 +24,7 @@ import SettingsModal from 'react-devtools-shared/src/devtools/views/Settings/Set import {NativeStyleContextController} from './NativeStyleEditor/context'; import styles from './Components.css'; +import typeof {SyntheticPointerEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; type Orientation = 'horizontal' | 'vertical'; @@ -79,17 +80,17 @@ function Components(_: {}) { return () => clearTimeout(timeoutID); }, [horizontalPercentage, verticalPercentage]); - const onResizeStart = (event: SyntheticPointerEvent) => { + const onResizeStart = (event: SyntheticPointerEvent) => { const element = event.currentTarget; element.setPointerCapture(event.pointerId); }; - const onResizeEnd = (event: SyntheticPointerEvent) => { + const onResizeEnd = (event: SyntheticPointerEvent) => { const element = event.currentTarget; element.releasePointerCapture(event.pointerId); }; - const onResize = (event: SyntheticPointerEvent) => { + const onResize = (event: SyntheticPointerEvent) => { const element = event.currentTarget; const isResizing = element.hasPointerCapture(event.pointerId); if (!isResizing) { diff --git a/packages/react-devtools-shared/src/devtools/views/Profiler/ChartNode.js b/packages/react-devtools-shared/src/devtools/views/Profiler/ChartNode.js index ef3d47f4011ca..a6acf53fcd0de 100644 --- a/packages/react-devtools-shared/src/devtools/views/Profiler/ChartNode.js +++ b/packages/react-devtools-shared/src/devtools/views/Profiler/ChartNode.js @@ -10,16 +10,17 @@ import * as React from 'react'; import styles from './ChartNode.css'; +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; type Props = { color: string, height: number, isDimmed?: boolean, label: string, - onClick: (event: SyntheticMouseEvent) => mixed, - onDoubleClick?: (event: SyntheticMouseEvent) => mixed, - onMouseEnter: (event: SyntheticMouseEvent) => mixed, - onMouseLeave: (event: SyntheticMouseEvent) => mixed, + onClick: (event: SyntheticMouseEvent) => mixed, + onDoubleClick?: (event: SyntheticMouseEvent) => mixed, + onMouseEnter: (event: SyntheticMouseEvent) => mixed, + onMouseLeave: (event: SyntheticMouseEvent) => mixed, placeLabelAboveNode?: boolean, textStyle?: Object, width: number, diff --git a/packages/react-devtools-shared/src/devtools/views/Profiler/CommitFlamegraphListItem.js b/packages/react-devtools-shared/src/devtools/views/Profiler/CommitFlamegraphListItem.js index 1fc586ed42b6a..f747b7ab4ab3f 100644 --- a/packages/react-devtools-shared/src/devtools/views/Profiler/CommitFlamegraphListItem.js +++ b/packages/react-devtools-shared/src/devtools/views/Profiler/CommitFlamegraphListItem.js @@ -17,6 +17,7 @@ import {SettingsContext} from '../Settings/SettingsContext'; import type {ChartNode as ChartNodeType} from './FlamegraphChartBuilder'; import type {ItemData} from './CommitFlamegraph'; +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; type Props = { data: ItemData, @@ -41,7 +42,7 @@ function CommitFlamegraphListItem({data, index, style}: Props): React.Node { const {lineHeight} = useContext(SettingsContext); const handleClick = useCallback( - (event: SyntheticMouseEvent, id: number, name: string) => { + (event: SyntheticMouseEvent, id: number, name: string) => { event.stopPropagation(); selectFiber(id, name); }, diff --git a/packages/react-devtools-shared/src/devtools/views/Profiler/Tooltip.js b/packages/react-devtools-shared/src/devtools/views/Profiler/Tooltip.js index b43f51cb04e23..6b92ef26c791c 100644 --- a/packages/react-devtools-shared/src/devtools/views/Profiler/Tooltip.js +++ b/packages/react-devtools-shared/src/devtools/views/Profiler/Tooltip.js @@ -4,6 +4,7 @@ import * as React from 'react'; import {useRef} from 'react'; import styles from './Tooltip.css'; +import typeof {SyntheticMouseEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; const initialTooltipState = {height: 0, mouseX: 0, mouseY: 0, width: 0}; @@ -17,7 +18,7 @@ export default function Tooltip({ const tooltipRef = useRef(null); // update the position of the tooltip based on current mouse position - const updateTooltipPosition = (event: SyntheticMouseEvent) => { + const updateTooltipPosition = (event: SyntheticMouseEvent) => { const element = tooltipRef.current; if (element != null) { // first find the mouse position @@ -30,7 +31,7 @@ export default function Tooltip({ } }; - const onMouseMove = (event: SyntheticMouseEvent) => { + const onMouseMove = (event: SyntheticMouseEvent) => { updateTooltipPosition(event); }; @@ -94,7 +95,7 @@ function getTooltipPosition( // method used to find the current mouse position inside the container function getMousePosition( relativeContainer: null, - mouseEvent: SyntheticMouseEvent, + mouseEvent: SyntheticMouseEvent, ) { if (relativeContainer !== null) { // Position within the nearest position:relative container. diff --git a/packages/react-devtools-shared/src/devtools/views/Settings/ProfilerSettings.js b/packages/react-devtools-shared/src/devtools/views/Settings/ProfilerSettings.js index 604fe4cba14d4..75bb97d902e2f 100644 --- a/packages/react-devtools-shared/src/devtools/views/Settings/ProfilerSettings.js +++ b/packages/react-devtools-shared/src/devtools/views/Settings/ProfilerSettings.js @@ -14,6 +14,7 @@ import {StoreContext} from '../context'; import {ProfilerContext} from 'react-devtools-shared/src/devtools/views/Profiler/ProfilerContext'; import styles from './SettingsShared.css'; +import typeof {SyntheticEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; export default function ProfilerSettings(_: {}): React.Node { const { @@ -45,7 +46,7 @@ export default function ProfilerSettings(_: {}): React.Node { [store], ); const updateMinCommitDuration = useCallback( - (event: SyntheticEvent) => { + (event: SyntheticEvent) => { const newValue = parseFloat(event.currentTarget.value); setMinCommitDuration( Number.isNaN(newValue) || newValue <= 0 ? 0 : newValue, @@ -54,7 +55,7 @@ export default function ProfilerSettings(_: {}): React.Node { [setMinCommitDuration], ); const updateIsCommitFilterEnabled = useCallback( - (event: SyntheticEvent) => { + (event: SyntheticEvent) => { const checked = event.currentTarget.checked; setIsCommitFilterEnabled(checked); if (checked) { diff --git a/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseRects.js b/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseRects.js index 793db5f97e0df..65fa4dec07396 100644 --- a/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseRects.js +++ b/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseRects.js @@ -23,6 +23,10 @@ import {StoreContext} from '../context'; import {useHighlightHostInstance} from '../hooks'; import styles from './SuspenseRects.css'; import {SuspenseTreeStateContext} from './SuspenseTreeContext'; +import typeof { + SyntheticMouseEvent, + SyntheticPointerEvent, +} from 'react-dom-bindings/src/events/SyntheticEvent'; function SuspenseRect({rect}: {rect: Rect}): React$Node { return ( @@ -55,7 +59,7 @@ function SuspenseRects({ return null; } - function handleClick(event: SyntheticMouseEvent<>) { + function handleClick(event: SyntheticMouseEvent) { if (event.defaultPrevented) { // Already clicked on an inner rect return; @@ -64,7 +68,7 @@ function SuspenseRects({ dispatch({type: 'SELECT_ELEMENT_BY_ID', payload: suspenseID}); } - function handlePointerOver(event: SyntheticPointerEvent<>) { + function handlePointerOver(event: SyntheticPointerEvent) { if (event.defaultPrevented) { // Already hovered an inner rect return; @@ -73,7 +77,7 @@ function SuspenseRects({ highlightHostInstance(suspenseID); } - function handlePointerLeave(event: SyntheticPointerEvent<>) { + function handlePointerLeave(event: SyntheticPointerEvent) { if (event.defaultPrevented) { // Already hovered an inner rect return; diff --git a/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseTab.js b/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseTab.js index dc0816bc2c285..19c039e1dc7e0 100644 --- a/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseTab.js +++ b/packages/react-devtools-shared/src/devtools/views/SuspenseTab/SuspenseTab.js @@ -22,6 +22,7 @@ import styles from './SuspenseTab.css'; import SuspenseRects from './SuspenseRects'; import SuspenseTreeList from './SuspenseTreeList'; import Button from '../Button'; +import typeof {SyntheticPointerEvent} from 'react-dom-bindings/src/events/SyntheticEvent'; type Orientation = 'horizontal' | 'vertical'; @@ -180,17 +181,17 @@ function SuspenseTab(_: {}) { treeListHorizontalFraction, ]); - const onResizeStart = (event: SyntheticPointerEvent) => { + const onResizeStart = (event: SyntheticPointerEvent) => { const element = event.currentTarget; element.setPointerCapture(event.pointerId); }; - const onResizeEnd = (event: SyntheticPointerEvent) => { + const onResizeEnd = (event: SyntheticPointerEvent) => { const element = event.currentTarget; element.releasePointerCapture(event.pointerId); }; - const onResizeTree = (event: SyntheticPointerEvent) => { + const onResizeTree = (event: SyntheticPointerEvent) => { const element = event.currentTarget; const isResizing = element.hasPointerCapture(event.pointerId); if (!isResizing) { @@ -241,7 +242,7 @@ function SuspenseTab(_: {}) { } }; - const onResizeTreeList = (event: SyntheticPointerEvent) => { + const onResizeTreeList = (event: SyntheticPointerEvent) => { const element = event.currentTarget; const isResizing = element.hasPointerCapture(event.pointerId); if (!isResizing) { diff --git a/packages/react-dom-bindings/src/client/ReactDOMEventHandle.js b/packages/react-dom-bindings/src/client/ReactDOMEventHandle.js index 26d821a6d9866..875a9c9697c3d 100644 --- a/packages/react-dom-bindings/src/client/ReactDOMEventHandle.js +++ b/packages/react-dom-bindings/src/client/ReactDOMEventHandle.js @@ -28,6 +28,7 @@ import { enableScopeAPI, enableCreateEventHandleAPI, } from 'shared/ReactFeatureFlags'; +import typeof {SyntheticEvent} from '../events/SyntheticEvent'; type EventHandleOptions = { capture?: boolean, @@ -44,7 +45,7 @@ function isReactScope(target: EventTarget | ReactScopeInstance): boolean { function createEventHandleListener( type: DOMEventName, isCapturePhaseListener: boolean, - callback: (SyntheticEvent) => void, + callback: SyntheticEvent => void, ): ReactDOMEventHandleListener { return { callback, @@ -111,7 +112,7 @@ export function createEventHandle( const eventHandle: ReactDOMEventHandle = ( target: EventTarget | ReactScopeInstance, - callback: (SyntheticEvent) => void, + callback: SyntheticEvent => void, ) => { if (typeof callback !== 'function') { throw new Error( diff --git a/packages/react-dom-bindings/src/client/ReactDOMEventHandleTypes.js b/packages/react-dom-bindings/src/client/ReactDOMEventHandleTypes.js index d0a1406a3f6e2..4c9a097afa3df 100644 --- a/packages/react-dom-bindings/src/client/ReactDOMEventHandleTypes.js +++ b/packages/react-dom-bindings/src/client/ReactDOMEventHandleTypes.js @@ -9,14 +9,15 @@ import type {ReactScopeInstance} from 'shared/ReactTypes'; import type {DOMEventName} from '../events/DOMEventNames'; +import typeof {SyntheticEvent} from '../events/SyntheticEvent'; export type ReactDOMEventHandle = ( target: EventTarget | ReactScopeInstance, - callback: (SyntheticEvent) => void, + callback: (SyntheticEvent) => void, ) => () => void; export type ReactDOMEventHandleListener = { - callback: (SyntheticEvent) => void, + callback: SyntheticEvent => void, capture: boolean, type: DOMEventName, }; diff --git a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js index 76f59b1fc541d..ffb50de0d9d8b 100644 --- a/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js +++ b/packages/react-dom-bindings/src/client/ReactFiberConfigDOM.js @@ -242,10 +242,10 @@ export type TransitionStatus = FormStatus; export type ViewTransitionInstance = { name: string, - group: Animatable, - imagePair: Animatable, - old: Animatable, - new: Animatable, + group: mixin$Animatable, + imagePair: mixin$Animatable, + old: mixin$Animatable, + new: mixin$Animatable, }; type SelectionInformation = { @@ -1430,7 +1430,10 @@ export function applyViewTransitionName( // simple case by converting it automatically to display: inline-block. // https://bugs.webkit.org/show_bug.cgi?id=290923 const rects = instance.getClientRects(); - if (countClientRects(rects) === 1) { + if ( + // $FlowFixMe[incompatible-call] + countClientRects(rects) === 1 + ) { // If the instance has a single client rect, that means that it can be // expressed as a display: inline-block or block. // This will cause layout thrash but we live with it since inline view transitions @@ -1535,6 +1538,7 @@ export function cancelViewTransitionName( if (documentElement !== null) { documentElement.animate( {opacity: [0, 0], pointerEvents: ['none', 'none']}, + // $FlowFixMe[incompatible-call] { duration: 0, fill: 'forwards', @@ -1571,6 +1575,7 @@ export function cancelRootViewTransitionName(rootContainer: Container): void { documentElement.style.viewTransitionName = 'none'; documentElement.animate( {opacity: [0, 0], pointerEvents: ['none', 'none']}, + // $FlowFixMe[incompatible-call] { duration: 0, fill: 'forwards', @@ -1586,6 +1591,7 @@ export function cancelRootViewTransitionName(rootContainer: Container): void { // whatever is below the animation. documentElement.animate( {width: [0, 0], height: [0, 0]}, + // $FlowFixMe[incompatible-call] { duration: 0, fill: 'forwards', @@ -1970,6 +1976,7 @@ export function hasInstanceAffectedParent( function cancelAllViewTransitionAnimations(scope: Element) { // In Safari, we need to manually cancel all manually start animations // or it'll block or interfer with future transitions. + // $FlowFixMe[prop-missing] const animations = scope.getAnimations({subtree: true}); for (let i = 0; i < animations.length; i++) { const anim = animations[i]; @@ -2137,6 +2144,7 @@ export function startViewTransition( const readyCallback = () => { const documentElement: Element = (ownerDocument.documentElement: any); // Loop through all View Transition Animations. + // $FlowFixMe[prop-missing] const animations = documentElement.getAnimations({subtree: true}); for (let i = 0; i < animations.length; i++) { const animation = animations[i]; @@ -2383,6 +2391,7 @@ function animateGesture( const reverse = rangeStart > rangeEnd; if (timeline instanceof AnimationTimeline) { // Native Timeline + // $FlowFixMe[incompatible-call] targetElement.animate(keyframes, { pseudoElement: pseudoElement, // Set the timeline to the current gesture timeline to drive the updates. @@ -2403,6 +2412,7 @@ function animateGesture( }); } else { // Custom Timeline + // $FlowFixMe[incompatible-call] const animation = targetElement.animate(keyframes, { pseudoElement: pseudoElement, // We reset all easing functions to linear so that it feels like you @@ -2456,6 +2466,7 @@ export function startGestureTransition( const readyCallback = () => { const documentElement: Element = (ownerDocument.documentElement: any); // Loop through all View Transition Animations. + // $FlowFixMe[prop-missing] const animations = documentElement.getAnimations({subtree: true}); // First do a pass to collect all known group and new items so we can look // up if they exist later. @@ -2471,8 +2482,11 @@ export function startGestureTransition( } else if (pseudoElement.startsWith('::view-transition')) { const timing = effect.getTiming(); const duration = + // $FlowFixMe[prop-missing] typeof timing.duration === 'number' ? timing.duration : 0; // TODO: Consider interation count higher than 1. + // $FlowFixMe[prop-missing] + // $FlowFixMe[unsafe-addition] const durationWithDelay = timing.delay + duration; if (durationWithDelay > longestDuration) { longestDuration = durationWithDelay; @@ -2532,11 +2546,17 @@ export function startGestureTransition( // therefore the timing is from the rangeEnd to the start. const timing = effect.getTiming(); const duration = + // $FlowFixMe[prop-missing] typeof timing.duration === 'number' ? timing.duration : 0; let adjustedRangeStart = + // $FlowFixMe[unsafe-addition] + // $FlowFixMe[prop-missing] rangeEnd - (duration + timing.delay) * durationToRangeMultipler; let adjustedRangeEnd = - rangeEnd - timing.delay * durationToRangeMultipler; + rangeEnd - + // $FlowFixMe[prop-missing] + // $FlowFixMe[unsafe-arithmetic] + timing.delay * durationToRangeMultipler; if ( timing.direction === 'reverse' || timing.direction === 'alternate-reverse' @@ -2594,6 +2614,7 @@ export function startGestureTransition( // you can swipe back again. We can prevent this by adding a paused Animation // that never stops. This seems to keep all running Animations alive until // we explicitly abort (or something forces the View Transition to cancel). + // $FlowFixMe[incompatible-call] const blockingAnim = documentElement.animate([{}, {}], { pseudoElement: '::view-transition', duration: 1, @@ -2658,7 +2679,7 @@ export function stopViewTransition(transition: RunningViewTransition) { transition.skipTransition(); } -interface ViewTransitionPseudoElementType extends Animatable { +interface ViewTransitionPseudoElementType extends mixin$Animatable { _scope: HTMLElement; _selector: string; getComputedStyle(): CSSStyleDeclaration; @@ -2684,7 +2705,11 @@ ViewTransitionPseudoElement.prototype.animate = function ( ? { duration: options, } - : Object.assign(({}: KeyframeAnimationOptions), options); + : Object.assign( + (// $FlowFixMe[prop-missing] + {}: KeyframeAnimationOptions), + options, + ); opts.pseudoElement = this._selector; // TODO: Handle multiple child instances. return this._scope.animate(keyframes, opts); @@ -2696,7 +2721,10 @@ ViewTransitionPseudoElement.prototype.getAnimations = function ( ): Animation[] { const scope = this._scope; const selector = this._selector; - const animations = scope.getAnimations({subtree: true}); + const animations = scope.getAnimations( + // $FlowFixMe[prop-missing] + {subtree: true}, + ); const result = []; for (let i = 0; i < animations.length; i++) { const effect: null | { @@ -5335,6 +5363,7 @@ function insertStylesheet( let prior = last; for (let i = 0; i < nodes.length; i++) { const node = nodes[i]; + // $FlowFixMe[prop-missing] const nodePrecedence = node.dataset.precedence; if (nodePrecedence === precedence) { prior = node; @@ -6110,7 +6139,11 @@ function insertStylesheetIntoRoot( // and will be hoisted by the Fizz runtime imminently. node.getAttribute('media') !== 'not all' ) { - precedences.set(node.dataset.precedence, node); + precedences.set( + // $FlowFixMe[prop-missing] + node.dataset.precedence, + node, + ); last = node; } } diff --git a/packages/react-dom-bindings/src/events/SyntheticEvent.js b/packages/react-dom-bindings/src/events/SyntheticEvent.js index 66be754fea2da..469cd0f010c3b 100644 --- a/packages/react-dom-bindings/src/events/SyntheticEvent.js +++ b/packages/react-dom-bindings/src/events/SyntheticEvent.js @@ -229,6 +229,7 @@ const MouseEventInterface: EventInterfaceType = { return lastMovementY; }, }; + export const SyntheticMouseEvent: $FlowFixMe = createSyntheticEvent(MouseEventInterface); diff --git a/packages/react-dom-bindings/src/shared/validAriaProperties.js b/packages/react-dom-bindings/src/shared/validAriaProperties.js index fb72fea260640..9421ba5a15616 100644 --- a/packages/react-dom-bindings/src/shared/validAriaProperties.js +++ b/packages/react-dom-bindings/src/shared/validAriaProperties.js @@ -59,6 +59,11 @@ const ariaProperties = { 'aria-rowindex': 0, 'aria-rowspan': 0, 'aria-setsize': 0, + // ARIA 1.3 Attributes + 'aria-braillelabel': 0, + 'aria-brailleroledescription': 0, + 'aria-colindextext': 0, + 'aria-rowindextext': 0, }; export default ariaProperties; diff --git a/packages/react-dom/src/ReactDOMSharedInternals.js b/packages/react-dom/src/ReactDOMSharedInternals.js index 38a7d45dc5e9e..b82535b67a155 100644 --- a/packages/react-dom/src/ReactDOMSharedInternals.js +++ b/packages/react-dom/src/ReactDOMSharedInternals.js @@ -21,9 +21,7 @@ type ReactDOMInternals = { p /* currentUpdatePriority */: EventPriority, findDOMNode: | null - | (( - componentOrElement: React$Component, - ) => null | Element | Text), + | ((componentOrElement: component(...props: any)) => null | Element | Text), }; function requestFormReset(element: HTMLFormElement) { diff --git a/packages/react-dom/src/ReactDOMSharedInternalsFB.js b/packages/react-dom/src/ReactDOMSharedInternalsFB.js index 03c1b4f11b778..6c91096c7478b 100644 --- a/packages/react-dom/src/ReactDOMSharedInternalsFB.js +++ b/packages/react-dom/src/ReactDOMSharedInternalsFB.js @@ -20,9 +20,7 @@ type ReactDOMInternals = { p /* currentUpdatePriority */: EventPriority, findDOMNode: | null - | (( - componentOrElement: React$Component, - ) => null | Element | Text), + | ((componentOrElement: component(...props: any)) => null | Element | Text), }; const DefaultDispatcher: HostDispatcher = { diff --git a/packages/react-dom/src/__tests__/ReactDOMInvalidARIAHook-test.js b/packages/react-dom/src/__tests__/ReactDOMInvalidARIAHook-test.js index 725cedab1f15a..a5fd14e95c96b 100644 --- a/packages/react-dom/src/__tests__/ReactDOMInvalidARIAHook-test.js +++ b/packages/react-dom/src/__tests__/ReactDOMInvalidARIAHook-test.js @@ -37,6 +37,27 @@ describe('ReactDOMInvalidARIAHook', () => { it('should allow valid aria-* props', async () => { await mountComponent({'aria-label': 'Bumble bees'}); }); + + it('should allow new ARIA 1.3 attributes', async () => { + // Test aria-braillelabel + await mountComponent({'aria-braillelabel': 'Braille label text'}); + + // Test aria-brailleroledescription + await mountComponent({'aria-brailleroledescription': 'Navigation menu'}); + + // Test aria-colindextext + await mountComponent({'aria-colindextext': 'Column A'}); + + // Test aria-rowindextext + await mountComponent({'aria-rowindextext': 'Row 1'}); + + // Test multiple ARIA 1.3 attributes together + await mountComponent({ + 'aria-braillelabel': 'Braille text', + 'aria-colindextext': 'First column', + 'aria-rowindextext': 'First row', + }); + }); it('should warn for one invalid aria-* prop', async () => { await mountComponent({'aria-badprop': 'maybe'}); assertConsoleErrorDev([ diff --git a/packages/react-dom/src/client/ReactDOMClient.js b/packages/react-dom/src/client/ReactDOMClient.js index 4c054ecceb9e6..9a9f3157b8227 100644 --- a/packages/react-dom/src/client/ReactDOMClient.js +++ b/packages/react-dom/src/client/ReactDOMClient.js @@ -41,7 +41,7 @@ if (__DEV__) { } function findDOMNode( - componentOrElement: React$Component, + componentOrElement: component(...props: any), ): null | Element | Text { return findHostInstance(componentOrElement); } diff --git a/packages/react-dom/src/client/ReactDOMClientFB.js b/packages/react-dom/src/client/ReactDOMClientFB.js index 8aa17df05dd0e..872a4550aa36a 100644 --- a/packages/react-dom/src/client/ReactDOMClientFB.js +++ b/packages/react-dom/src/client/ReactDOMClientFB.js @@ -109,7 +109,7 @@ const flushSync: typeof flushSyncIsomorphic = disableLegacyMode : flushSyncFromReconciler; function findDOMNode( - componentOrElement: React$Component, + componentOrElement: component(...props: any), ): null | Element | Text { return findHostInstance(componentOrElement); } diff --git a/packages/react-dom/src/client/ReactDOMRoot.js b/packages/react-dom/src/client/ReactDOMRoot.js index 97f4c83515364..a32cefe81d5b1 100644 --- a/packages/react-dom/src/client/ReactDOMRoot.js +++ b/packages/react-dom/src/client/ReactDOMRoot.js @@ -39,7 +39,7 @@ export type CreateRootOptions = { error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError?: ( @@ -65,7 +65,7 @@ export type HydrateRootOptions = { error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError?: ( diff --git a/packages/react-dom/src/client/ReactDOMRootFB.js b/packages/react-dom/src/client/ReactDOMRootFB.js index 66a373b0f6ca2..757c3d69eb5ef 100644 --- a/packages/react-dom/src/client/ReactDOMRootFB.js +++ b/packages/react-dom/src/client/ReactDOMRootFB.js @@ -106,7 +106,7 @@ function wwwOnCaughtError( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(), }, ): void { const errorBoundary = errorInfo.errorBoundary; @@ -216,7 +216,7 @@ const noopOnDefaultTransitionIndicator = noop; function legacyCreateRootFromDOMContainer( container: Container, initialChildren: ReactNodeList, - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), callback: ?Function, isHydrationContainer: boolean, ): FiberRoot { @@ -314,12 +314,12 @@ function warnOnInvalidCallback(callback: mixed): void { } function legacyRenderSubtreeIntoContainer( - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), children: ReactNodeList, container: Container, forceHydrate: boolean, callback: ?Function, -): React$Component | PublicInstance | null { +): component(...props: any) | PublicInstance | null { if (__DEV__) { topLevelUpdateWarnings(container); warnOnInvalidCallback(callback === undefined ? null : callback); @@ -352,7 +352,7 @@ function legacyRenderSubtreeIntoContainer( } export function findDOMNode( - componentOrElement: Element | ?React$Component, + componentOrElement: Element | ?component(...props: any), ): null | Element | Text { if (__DEV__) { const owner = currentOwner; @@ -387,7 +387,7 @@ export function render( element: React$Element, container: Container, callback: ?Function, -): React$Component | PublicInstance | null { +): component(...props: any) | PublicInstance | null { if (disableLegacyMode) { if (__DEV__) { console.error( diff --git a/packages/react-native-renderer/src/ReactFabric.js b/packages/react-native-renderer/src/ReactFabric.js index 3f77085c6882a..04590023bd7a5 100644 --- a/packages/react-native-renderer/src/ReactFabric.js +++ b/packages/react-native-renderer/src/ReactFabric.js @@ -78,7 +78,7 @@ function nativeOnCaughtError( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ): void { const errorBoundary = errorInfo.errorBoundary; diff --git a/packages/react-native-renderer/src/ReactNativeRenderer.js b/packages/react-native-renderer/src/ReactNativeRenderer.js index 8f26bfc314d95..c7f7a11dcc57b 100644 --- a/packages/react-native-renderer/src/ReactNativeRenderer.js +++ b/packages/react-native-renderer/src/ReactNativeRenderer.js @@ -93,7 +93,7 @@ function nativeOnCaughtError( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ): void { const errorBoundary = errorInfo.errorBoundary; diff --git a/packages/react-noop-renderer/src/createReactNoop.js b/packages/react-noop-renderer/src/createReactNoop.js index 37d3e5fd12a11..83cbb24744a9c 100644 --- a/packages/react-noop-renderer/src/createReactNoop.js +++ b/packages/react-noop-renderer/src/createReactNoop.js @@ -1387,7 +1387,7 @@ function createReactNoop(reconciler: Function, useMutation: boolean) { }, findInstance( - componentOrElement: Element | ?React$Component, + componentOrElement: Element | ?component(...props: any), ): null | Instance | TextInstance { if (componentOrElement == null) { return null; diff --git a/packages/react-reconciler/src/ReactFiberErrorLogger.js b/packages/react-reconciler/src/ReactFiberErrorLogger.js index fe8224bbdca7f..e6111d8be74a4 100644 --- a/packages/react-reconciler/src/ReactFiberErrorLogger.js +++ b/packages/react-reconciler/src/ReactFiberErrorLogger.js @@ -61,7 +61,7 @@ export function defaultOnCaughtError( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ): void { // Overriding this can silence these warnings e.g. for tests. diff --git a/packages/react-reconciler/src/ReactFiberReconciler.js b/packages/react-reconciler/src/ReactFiberReconciler.js index 8d0f71d16b391..14764c0dcb7e9 100644 --- a/packages/react-reconciler/src/ReactFiberReconciler.js +++ b/packages/react-reconciler/src/ReactFiberReconciler.js @@ -138,7 +138,7 @@ if (__DEV__) { } function getContextForSubtree( - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), ): Object { if (!parentComponent) { return emptyContextObject; @@ -248,7 +248,7 @@ export function createContainer( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError: ( @@ -298,7 +298,7 @@ export function createHydrationContainer( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError: ( @@ -355,7 +355,7 @@ export function createHydrationContainer( export function updateContainer( element: ReactNodeList, container: OpaqueRoot, - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), callback: ?Function, ): Lane { const current = container.current; @@ -374,7 +374,7 @@ export function updateContainer( export function updateContainerSync( element: ReactNodeList, container: OpaqueRoot, - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), callback: ?Function, ): Lane { if (!disableLegacyMode && container.tag === LegacyRoot) { @@ -397,7 +397,7 @@ function updateContainerImpl( lane: Lane, element: ReactNodeList, container: OpaqueRoot, - parentComponent: ?React$Component, + parentComponent: ?component(...props: any), callback: ?Function, ): void { if (__DEV__) { @@ -471,7 +471,7 @@ export { export function getPublicRootInstance( container: OpaqueRoot, -): React$Component | PublicInstance | null { +): component(...props: any) | PublicInstance | null { const containerFiber = container.current; if (!containerFiber.child) { return null; diff --git a/packages/react-reconciler/src/ReactFiberRoot.js b/packages/react-reconciler/src/ReactFiberRoot.js index e9d107bcb899c..908893db9489c 100644 --- a/packages/react-reconciler/src/ReactFiberRoot.js +++ b/packages/react-reconciler/src/ReactFiberRoot.js @@ -176,7 +176,7 @@ export function createFiberRoot( error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError: ( diff --git a/packages/react-reconciler/src/ReactInternalTypes.js b/packages/react-reconciler/src/ReactInternalTypes.js index b8d66015fc772..95c3b8ca89cb9 100644 --- a/packages/react-reconciler/src/ReactInternalTypes.js +++ b/packages/react-reconciler/src/ReactInternalTypes.js @@ -273,7 +273,7 @@ type BaseFiberRootProperties = { error: mixed, errorInfo: { +componentStack?: ?string, - +errorBoundary?: ?React$Component, + +errorBoundary?: ?component(...props: any), }, ) => void, onRecoverableError: ( diff --git a/packages/react-server/src/ReactFizzClassComponent.js b/packages/react-server/src/ReactFizzClassComponent.js index ffa0c4a402469..28c8ac6edcb30 100644 --- a/packages/react-server/src/ReactFizzClassComponent.js +++ b/packages/react-server/src/ReactFizzClassComponent.js @@ -79,7 +79,7 @@ function warnOnUndefinedDerivedState(type: any, partialState: any) { } function warnNoop( - publicInstance: React$Component, + publicInstance: component(...props: any), callerName: string, ) { if (__DEV__) { diff --git a/packages/react-test-renderer/src/ReactTestRenderer.js b/packages/react-test-renderer/src/ReactTestRenderer.js index e843417e83b5b..d4466b34279dd 100644 --- a/packages/react-test-renderer/src/ReactTestRenderer.js +++ b/packages/react-test-renderer/src/ReactTestRenderer.js @@ -473,7 +473,7 @@ function create( toTree(): mixed, update(newElement: React$Element): any, unmount(): void, - getInstance(): React$Component | PublicInstance | null, + getInstance(): component(...props: any) | PublicInstance | null, unstable_flushSync: typeof flushSyncFromReconciler, } { if (__DEV__) { diff --git a/yarn.lock b/yarn.lock index a1ab0f5cc4386..0acce52fd454b 100644 --- a/yarn.lock +++ b/yarn.lock @@ -53,6 +53,15 @@ dependencies: "@babel/highlight" "^7.12.13" +"@babel/code-frame@^7.16.7", "@babel/code-frame@^7.27.1": + version "7.27.1" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be" + integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg== + dependencies: + "@babel/helper-validator-identifier" "^7.27.1" + js-tokens "^4.0.0" + picocolors "^1.1.1" + "@babel/code-frame@^7.21.4": version "7.24.7" resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.24.7.tgz#882fd9e09e8ee324e496bd040401c6f046ef4465" @@ -70,15 +79,6 @@ js-tokens "^4.0.0" picocolors "^1.0.0" -"@babel/code-frame@^7.27.1": - version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be" - integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg== - dependencies: - "@babel/helper-validator-identifier" "^7.27.1" - js-tokens "^4.0.0" - picocolors "^1.1.1" - "@babel/code-frame@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.8.3.tgz#33e25903d7481181534e12ec0a25f16b6fcf419e" @@ -871,6 +871,16 @@ js-tokens "^4.0.0" picocolors "^1.0.0" +"@babel/highlight@^7.16.7": + version "7.25.9" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.25.9.tgz#8141ce68fc73757946f983b343f1231f4691acc6" + integrity sha512-llL88JShoCsth8fF8R4SJnIn+WLvR6ccFxu1H3FlMhDontdcmZWf2HgIZ7AIqV3Xcck1idlohrN4EUBQz6klbw== + dependencies: + "@babel/helper-validator-identifier" "^7.25.9" + chalk "^2.4.2" + js-tokens "^4.0.0" + picocolors "^1.0.0" + "@babel/highlight@^7.24.7": version "7.24.7" resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.24.7.tgz#a05ab1df134b286558aae0ed41e6c5f731bf409d" @@ -3272,6 +3282,18 @@ "@jridgewell/resolve-uri" "^3.1.0" "@jridgewell/sourcemap-codec" "^1.4.14" +"@kwsites/file-exists@^1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@kwsites/file-exists/-/file-exists-1.1.1.tgz#ad1efcac13e1987d8dbaf235ef3be5b0d96faa99" + integrity sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw== + dependencies: + debug "^4.1.1" + +"@kwsites/promise-deferred@^1.1.1": + version "1.1.1" + resolved "https://registry.yarnpkg.com/@kwsites/promise-deferred/-/promise-deferred-1.1.1.tgz#8ace5259254426ccef57f3175bc64ed7095ed919" + integrity sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw== + "@leichtgewicht/ip-codec@^2.0.1": version "2.0.4" resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz#b2ac626d6cb9c8718ab459166d4bb405b8ffa78b" @@ -6335,6 +6357,11 @@ char-regex@^1.0.2: resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== +charenc@0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/charenc/-/charenc-0.0.2.tgz#c0a1d2f3a7092e03774bfa83f14c0fc5790a8667" + integrity sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA== + cheerio-select@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cheerio-select/-/cheerio-select-2.1.0.tgz#4d8673286b8126ca2a8e42740d5e3c4884ae21b4" @@ -6641,7 +6668,7 @@ colors@1.0.3: resolved "https://registry.yarnpkg.com/colors/-/colors-1.0.3.tgz#0433f44d809680fdeb60ed260f1b0c262e82a40b" integrity sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs= -colors@^1.1.2: +colors@1.4.0, colors@^1.1.2: version "1.4.0" resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78" integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA== @@ -6683,6 +6710,11 @@ commander@^4.0.0, commander@^4.0.1: resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068" integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA== +commander@^6.1.0: + version "6.2.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" + integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA== + commander@^9.1.0: version "9.5.0" resolved "https://registry.yarnpkg.com/commander/-/commander-9.5.0.tgz#bc08d1eb5cedf7ccb797a96199d41c7bc3e60d30" @@ -7072,6 +7104,11 @@ crx@^5.0.0: node-rsa "^1.0.5" pbf "^3.2.0" +crypt@0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b" + integrity sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow== + crypto-browserify@~3.2.6: version "3.2.8" 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: dependencies: eslint-visitor-keys "^1.1.0" -"eslint-v7@npm:eslint@^7.7.0", eslint@^7.7.0: +"eslint-v7@npm:eslint@^7.7.0": version "7.32.0" resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d" integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA== @@ -8452,6 +8489,52 @@ eslint@8.57.0: strip-ansi "^6.0.1" text-table "^0.2.0" +eslint@^7.7.0: + version "7.32.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d" + integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA== + dependencies: + "@babel/code-frame" "7.12.11" + "@eslint/eslintrc" "^0.4.3" + "@humanwhocodes/config-array" "^0.5.0" + ajv "^6.10.0" + chalk "^4.0.0" + cross-spawn "^7.0.2" + debug "^4.0.1" + doctrine "^3.0.0" + enquirer "^2.3.5" + escape-string-regexp "^4.0.0" + eslint-scope "^5.1.1" + eslint-utils "^2.1.0" + eslint-visitor-keys "^2.0.0" + espree "^7.3.1" + esquery "^1.4.0" + esutils "^2.0.2" + fast-deep-equal "^3.1.3" + file-entry-cache "^6.0.1" + functional-red-black-tree "^1.0.1" + glob-parent "^5.1.2" + globals "^13.6.0" + ignore "^4.0.6" + import-fresh "^3.0.0" + imurmurhash "^0.1.4" + is-glob "^4.0.0" + js-yaml "^3.13.1" + json-stable-stringify-without-jsonify "^1.0.1" + levn "^0.4.1" + lodash.merge "^4.6.2" + minimatch "^3.0.4" + natural-compare "^1.4.0" + optionator "^0.9.1" + progress "^2.0.0" + regexpp "^3.1.0" + semver "^7.2.1" + strip-ansi "^6.0.0" + strip-json-comments "^3.1.0" + table "^6.0.9" + text-table "^0.2.0" + v8-compile-cache "^2.0.3" + espree@10.0.1, espree@^10.0.1: version "10.0.1" resolved "https://registry.yarnpkg.com/espree/-/espree-10.0.1.tgz#600e60404157412751ba4a6f3a2ee1a42433139f" @@ -9215,12 +9298,12 @@ flatted@^3.2.9: resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.3.1.tgz#21db470729a6734d4997002f439cb308987f567a" integrity sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw== -flow-bin@^0.261: - version "0.261.2" - resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.261.2.tgz#8558c965950f8e38872ea21f66bf04932da2380b" - integrity sha512-lTYA05K4obAjyrrX4in3sLZyAECSFCDwQiGpZHJLm8ldCk+qcW11Wcxq/CdvyQAOPR7Kpb5BPRSaj4hwEXIAUw== +flow-bin@^0.263: + version "0.263.0" + resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.263.0.tgz#0a836bdf82855d5df9858c781818ce51612be064" + integrity sha512-FkQywD+7wXru/7/SWJPVnZXUp6CW3XtrVZ26vhAdVfMx9xlwq/Zk/tXcn3OQuiHUA4kQvZNyfgRztp6oXgjsog== -flow-remove-types@^2.261: +flow-remove-types@^2.263: version "2.279.0" resolved "https://registry.yarnpkg.com/flow-remove-types/-/flow-remove-types-2.279.0.tgz#3a3388d9158eba0f82c40d80d31d9640b883a3f5" integrity sha512-bPFloMR/A2b/r/sIsf7Ix0LaMicCJNjwhXc4xEEQVzJCIz5u7C7XDaEOXOiqveKlCYK7DcBNn6R01Cbbc9gsYA== @@ -9229,6 +9312,43 @@ flow-remove-types@^2.261: pirates "^3.0.2" vlq "^0.2.1" +flow-typed@^4.1.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/flow-typed/-/flow-typed-4.1.1.tgz#e4ff8ea37edcb8fb463b72b70787147bf52a1e08" + integrity sha512-S1NSkTm81UkoSiuDp9vUAY+jYSB8r/Bec1RFqjK3o+XagFu+OQtm1nh3ZyoshHtg1oPKfrSnslXHlqWiP76BSw== + dependencies: + "@octokit/rest" "^18.12.0" + colors "1.4.0" + flowgen "^1.10.0" + fs-extra "^8.1.0" + glob "^7.1.6" + got "^11.8.5" + js-yaml "^4.1.0" + md5 "^2.2.1" + mkdirp "^1.0.3" + node-stream-zip "^1.15.0" + prettier "^1.19.1" + rimraf "^3.0.2" + semver "^7.6.3" + simple-git "^3.10.0" + table "^6.7.3" + which "^2.0.2" + yargs "^15.1.0" + +flowgen@^1.10.0: + version "1.21.0" + resolved "https://registry.yarnpkg.com/flowgen/-/flowgen-1.21.0.tgz#f7ecb693892c4bd069492dbf77db561bbb451aa9" + integrity sha512-pFNFFyMLRmW6njhOIm5TrbGUDTv64aujmys2KrkRE2NYD8sXwJUyicQRwU5SPRBRJnFSD/FNlnHo2NnHI5eJSw== + dependencies: + "@babel/code-frame" "^7.16.7" + "@babel/highlight" "^7.16.7" + commander "^6.1.0" + lodash "^4.17.20" + prettier "^2.5.1" + shelljs "^0.8.4" + typescript "~4.4.4" + typescript-compiler "^1.4.1-2" + follow-redirects@^1.0.0: version "1.15.6" resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b" @@ -10685,7 +10805,7 @@ is-boolean-object@^1.1.0: dependencies: call-bind "^1.0.2" -is-buffer@^1.1.5: +is-buffer@^1.1.5, is-buffer@~1.1.6: version "1.1.6" resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be" integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w== @@ -12304,7 +12424,7 @@ lodash.union@^4.6.0: resolved "https://registry.yarnpkg.com/lodash.union/-/lodash.union-4.6.0.tgz#48bb5088409f16f1821666641c44dd1aaae3cd88" integrity sha1-SLtQiECfFvGCFmZkHETdGqrjzYg= -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: +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: version "4.17.21" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== @@ -12509,6 +12629,15 @@ matcher@^3.0.0: dependencies: escape-string-regexp "^4.0.0" +md5@^2.2.1: + version "2.3.0" + resolved "https://registry.yarnpkg.com/md5/-/md5-2.3.0.tgz#c3da9a6aae3a30b46b7b0c349b87b110dc3bda4f" + integrity sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g== + dependencies: + charenc "0.0.2" + crypt "0.0.2" + is-buffer "~1.1.6" + mdn-data@2.0.14: version "2.0.14" 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: dependencies: minimist "^1.2.5" +mkdirp@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + moment@^2.19.3: version "2.30.1" resolved "https://registry.yarnpkg.com/moment/-/moment-2.30.1.tgz#f8c91c07b7a786e30c59926df530b4eac96974ae" @@ -13058,6 +13192,11 @@ node-rsa@^1.0.5: dependencies: asn1 "^0.2.4" +node-stream-zip@^1.15.0: + version "1.15.0" + resolved "https://registry.yarnpkg.com/node-stream-zip/-/node-stream-zip-1.15.0.tgz#158adb88ed8004c6c49a396b50a6a5de3bca33ea" + integrity sha512-LN4fydt9TqhZhThkZIVQnF9cwjU3qmUH9h78Mx/K7d3VvfRqqwthLwJEUOEL0QPZ0XQmNN7be5Ggit5+4dq3Bw== + node-version@^1.0.0: version "1.2.0" resolved "https://registry.yarnpkg.com/node-version/-/node-version-1.2.0.tgz#34fde3ffa8e1149bd323983479dda620e1b5060d" @@ -14207,6 +14346,16 @@ prettier@*, prettier@^3.3.3: resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.3.3.tgz#30c54fe0be0d8d12e6ae61dbb10109ea00d53105" integrity sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew== +prettier@^1.19.1: + version "1.19.1" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.19.1.tgz#f7d7f5ff8a9cd872a7be4ca142095956a60797cb" + integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew== + +prettier@^2.5.1: + version "2.8.8" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da" + integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q== + pretty-format@^29.4.1: version "29.4.1" resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.4.1.tgz#0da99b532559097b8254298da7c75a0785b1751c" @@ -15520,6 +15669,11 @@ semver@^7.5.4: dependencies: lru-cache "^6.0.0" +semver@^7.6.3: + version "7.7.2" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.7.2.tgz#67d99fdcd35cec21e6f8b87a7fd515a33f982b58" + integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA== + send@0.19.0: version "0.19.0" resolved "https://registry.yarnpkg.com/send/-/send-0.19.0.tgz#bbc5a388c8ea6c048967049dbeac0e4a3f09d7f8" @@ -15682,7 +15836,7 @@ shell-quote@^1.7.3: resolved "https://registry.yarnpkg.com/shell-quote/-/shell-quote-1.8.1.tgz#6dbf4db75515ad5bac63b4f1894c3a154c766680" integrity sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA== -shelljs@^0.8.5: +shelljs@^0.8.4, shelljs@^0.8.5: version "0.8.5" resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c" integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow== @@ -15726,6 +15880,15 @@ signedsource@^2.0.0: resolved "https://registry.yarnpkg.com/signedsource/-/signedsource-2.0.0.tgz#f72dc0f98f5bca2763b464a555511a84a4da8eee" integrity sha512-MscTxXbMij5JVgrW1xDiMIc+vFa0+H0+HP+rRrFjwa7ef2VAxIP/4L/E75I5H4xvyb4l1X+a9ch+6Zy5uFu7Fg== +simple-git@^3.10.0: + version "3.28.0" + resolved "https://registry.yarnpkg.com/simple-git/-/simple-git-3.28.0.tgz#c6345b2e387880f8450788a1e388573366ae48ac" + integrity sha512-Rs/vQRwsn1ILH1oBUy8NucJlXmnnLeLCfcvbSehkPzbv3wwoFWIdtfd6Ndo6ZPhlPsCZ60CPI4rxurnwAa+a2w== + dependencies: + "@kwsites/file-exists" "^1.1.1" + "@kwsites/promise-deferred" "^1.1.1" + debug "^4.4.0" + sisteransi@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" @@ -16067,7 +16230,7 @@ string-natural-compare@^3.0.1: resolved "https://registry.yarnpkg.com/string-natural-compare/-/string-natural-compare-3.0.1.tgz#7a42d58474454963759e8e8b7ae63d71c1e7fdf4" integrity sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw== -"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: +"string-width-cjs@npm:string-width@^4.2.0": version "4.2.3" resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== @@ -16102,6 +16265,15 @@ string-width@^4.0.0: is-fullwidth-code-point "^3.0.0" strip-ansi "^6.0.0" +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + string-width@^5.0.1, string-width@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794" @@ -16162,7 +16334,7 @@ string_decoder@~1.1.1: dependencies: safe-buffer "~5.1.0" -"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1: +"strip-ansi-cjs@npm:strip-ansi@^6.0.1": version "6.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== @@ -16190,6 +16362,13 @@ strip-ansi@^5.1.0: dependencies: ansi-regex "^4.1.0" +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + strip-ansi@^7.0.1: version "7.1.0" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45" @@ -16424,6 +16603,17 @@ table@^6.0.9: string-width "^4.2.3" strip-ansi "^6.0.1" +table@^6.7.3: + version "6.9.0" + resolved "https://registry.yarnpkg.com/table/-/table-6.9.0.tgz#50040afa6264141c7566b3b81d4d82c47a8668f5" + integrity sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A== + dependencies: + ajv "^8.0.1" + lodash.truncate "^4.4.2" + slice-ansi "^4.0.0" + string-width "^4.2.3" + strip-ansi "^6.0.1" + tapable@^2.1.1, tapable@^2.2.0, tapable@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0" @@ -16925,6 +17115,11 @@ typedarray@^0.0.6: resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= +typescript-compiler@^1.4.1-2: + version "1.4.1-2" + resolved "https://registry.yarnpkg.com/typescript-compiler/-/typescript-compiler-1.4.1-2.tgz#ba4f7db22d91534a1929d90009dce161eb72fd3f" + integrity sha512-EMopKmoAEJqA4XXRFGOb7eSBhmQMbBahW6P1Koayeatp0b4AW2q/bBqYWkpG7QVQc9HGQUiS4trx2ZHcnAaZUg== + typescript@3.9.3: version "3.9.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.3.tgz#d3ac8883a97c26139e42df5e93eeece33d610b8a" @@ -16935,6 +17130,11 @@ typescript@^5.4.3: resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.3.tgz#919b44a7dbb8583a9b856d162be24a54bf80073e" integrity sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw== +typescript@~4.4.4: + version "4.4.4" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.4.4.tgz#2cd01a1a1f160704d3101fd5a58ff0f9fcb8030c" + integrity sha512-DqGhF5IKoBl8WNf8C1gu8q0xZSInh9j1kJJMqT3a94w1JzVaBU4EXOSMrz9yDqMT0xt3selp83fuFMQ0uzv6qA== + ua-parser-js@^0.7.18, ua-parser-js@^0.7.9: version "0.7.20" 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: dependencies: loader-utils "^2.0.0" -"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0: +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": version "7.0.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== @@ -17790,6 +17990,15 @@ wrap-ansi@^6.2.0: string-width "^4.1.0" strip-ansi "^6.0.0" +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + wrap-ansi@^8.1.0: version "8.1.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214" @@ -17945,6 +18154,14 @@ yargs-parser@^18.1.1: camelcase "^5.0.0" decamelize "^1.2.0" +yargs-parser@^18.1.2: + version "18.1.3" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0" + integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ== + dependencies: + camelcase "^5.0.0" + decamelize "^1.2.0" + yargs-parser@^21.1.1: version "21.1.1" 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: y18n "^5.0.5" yargs-parser "^21.1.1" +yargs@^15.1.0: + version "15.4.1" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8" + integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A== + dependencies: + cliui "^6.0.0" + decamelize "^1.2.0" + find-up "^4.1.0" + get-caller-file "^2.0.1" + require-directory "^2.1.1" + require-main-filename "^2.0.0" + set-blocking "^2.0.0" + string-width "^4.2.0" + which-module "^2.0.0" + y18n "^4.0.0" + yargs-parser "^18.1.2" + yargs@^15.3.1: version "15.3.1" resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.3.1.tgz#9505b472763963e54afe60148ad27a330818e98b"