zzos/react-native-devtools-frontend
1
0
Fork 0
mirror of https://github.com/react/react-native-devtools-frontend.git synced 2026-10-09 05:08:28 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
700db8d40ca419ab4cebb9bf63aa8d3fcf52cecc
react-native-devtools-frontend/front_end/models/javascript_metadata/NativeFunctions.js
T
Wolfgang Beyer ca299d85c8 Update protocol 
DISABLE_THIRD_PARTY_CHECK=protocol_update

Bug: none
Change-Id: I3be70090c7936b70b1f01ce08d0f39a00ac2fd44
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/3229273
Reviewed-by: Alex Rudenko <alexrudenko@chromium.org>
Reviewed-by: Simon Zünd <szuend@chromium.org>
Commit-Queue: Wolfgang Beyer <wolfi@chromium.org>
2021-10-18 11:22:48 +00:00

5422 lines
160 KiB
JavaScript
Raw Blame History

// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated from scripts/javascript_natives/index.js
export const NativeFunctions = [
{name: 'find', signatures: [['predicate', '?thisArg']], receiver: 'Array'},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'ReadonlyArray',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Int8Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Uint8Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Uint8ClampedArray',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Int16Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Uint16Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Int32Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Uint32Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Float32Array',
},
{
name: 'find',
signatures: [['predicate', '?thisArg']],
receiver: 'Float64Array',
},
{
name: 'find',
signatures: [
[
'?string',
'?caseSensitive',
'?backwards',
'?wrap',
'?wholeWord',
'?searchInFrames',
'?showDialog',
],
],
receiver: 'Window',
},
{name: 'findIndex', signatures: [['predicate', '?thisArg']]},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Int8Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Uint8Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Uint8ClampedArray',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Int16Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Uint16Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Int32Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Uint32Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Float32Array',
},
{
name: 'fill',
signatures: [['value', '?start', '?end']],
receiver: 'Float64Array',
},
{
name: 'fill',
signatures: [['?winding'], ['path', '?winding']],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'fill',
signatures: [['?winding'], ['path', '?winding']],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'fill',
signatures: [['?winding'], ['path', '?winding']],
receiver: 'PaintRenderingContext2D',
},
{name: 'copyWithin', signatures: [['target', 'start', '?end']]},
{
name: 'from',
signatures: [
['arrayLike', '?mapfn', '?thisArg'],
['iterable', '?mapfn', '?thisArg'],
],
static: true,
receiver: 'Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Int8Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Uint8Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Uint8ClampedArray',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Int16Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Uint16Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Int32Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Uint32Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Float32Array',
},
{
name: 'from',
signatures: [['arrayLike', '?mapfn', '?thisArg']],
static: true,
receiver: 'Float64Array',
},
{name: 'of', signatures: [['...items']]},
{name: 'clz32', signatures: [['x']]},
{name: 'imul', signatures: [['x', 'y']]},
{name: 'sign', signatures: [['x']], receiver: 'Math'},
{
name: 'sign',
signatures: [['algorithm', 'key', 'data']],
receiver: 'SubtleCrypto',
},
{name: 'log10', signatures: [['x']]},
{name: 'log2', signatures: [['x']]},
{name: 'log1p', signatures: [['x']]},
{name: 'expm1', signatures: [['x']]},
{name: 'cosh', signatures: [['x']]},
{name: 'sinh', signatures: [['x']]},
{name: 'tanh', signatures: [['x']]},
{name: 'acosh', signatures: [['x']]},
{name: 'asinh', signatures: [['x']]},
{name: 'atanh', signatures: [['x']]},
{name: 'hypot', signatures: [['...values']]},
{name: 'trunc', signatures: [['x']]},
{name: 'fround', signatures: [['x']]},
{name: 'cbrt', signatures: [['x']]},
{name: 'isFinite', signatures: [['number']]},
{name: 'isInteger', signatures: [['number']]},
{name: 'isNaN', signatures: [['number']]},
{name: 'isSafeInteger', signatures: [['number']]},
{name: 'parseFloat', signatures: [['string']]},
{
name: 'parseInt',
signatures: [['string', '?radix']],
static: true,
receiver: 'Number',
},
{name: 'parseInt', signatures: [['s', '?radix']], receiver: 'Window'},
{
name: 'assign',
signatures: [
['target', 'source'],
['target', '...sources'],
['target', 'source1', 'source2', '?source3'],
],
static: true,
receiver: 'Object',
},
{name: 'assign', signatures: [['url']], receiver: 'Location'},
{name: 'assign', signatures: [['nodes']], receiver: 'HTMLSlotElement'},
{name: 'getOwnPropertySymbols', signatures: [['o']]},
{name: 'is', signatures: [['value1', 'value2']]},
{
name: 'setPrototypeOf',
signatures: [['o', 'proto']],
static: true,
receiver: 'Object',
},
{
name: 'setPrototypeOf',
signatures: [['target', 'v']],
receiver: 'ProxyHandler',
},
{name: 'codePointAt', signatures: [['pos']]},
{
name: 'includes',
signatures: [['searchString', '?position']],
receiver: 'String',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'ReadonlyArray',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int8Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8ClampedArray',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int16Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint16Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int32Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint32Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float32Array',
},
{
name: 'includes',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float64Array',
},
{name: 'includes', signatures: [['key']], receiver: 'IDBKeyRange'},
{name: 'endsWith', signatures: [['searchString', '?endPosition']]},
{name: 'normalize', signatures: [['?form']], receiver: 'String'},
{name: 'repeat', signatures: [['count']]},
{name: 'startsWith', signatures: [['searchString', '?position']]},
{name: 'anchor', signatures: [['name']]},
{name: 'fontcolor', signatures: [['color']]},
{name: 'fontsize', signatures: [['size']]},
{name: 'link', signatures: [['url']]},
{
name: 'sub',
signatures: [['typedArray', 'index', 'value']],
receiver: 'Atomics',
},
{name: 'sub', signatures: [['...values']], receiver: 'CSSNumericValue'},
{name: 'fromCodePoint', signatures: [['...codePoints']]},
{name: 'raw', signatures: [['template', '...substitutions']]},
{
name: 'clear',
signatures: [['mask']],
receiver: 'WebGLRenderingContextBase',
},
{name: 'delete', signatures: [['key']], receiver: 'Map'},
{name: 'delete', signatures: [['key']], receiver: 'WeakMap'},
{name: 'delete', signatures: [['value']], receiver: 'Set'},
{name: 'delete', signatures: [['value']], receiver: 'WeakSet'},
{name: 'delete', signatures: [['property']], receiver: 'StylePropertyMap'},
{name: 'delete', signatures: [['key']], receiver: 'Headers'},
{name: 'delete', signatures: [['name']], receiver: 'FormData'},
{name: 'delete', signatures: [['name']], receiver: 'URLSearchParams'},
{name: 'delete', signatures: [['cacheName']], receiver: 'CacheStorage'},
{name: 'delete', signatures: [['request', '?options']], receiver: 'Cache'},
{name: 'delete', signatures: [['id']], receiver: 'ContentIndex'},
{
name: 'delete',
signatures: [['name'], ['options']],
receiver: 'CookieStore',
},
{name: 'delete', signatures: [['key']], receiver: 'IDBObjectStore'},
{
name: 'delete',
signatures: [['instrumentKey']],
receiver: 'PaymentInstruments',
},
{name: 'forEach', signatures: [['callbackfn', '?thisArg']]},
{name: 'get', signatures: [['key']], receiver: 'Map'},
{name: 'get', signatures: [['key']], receiver: 'ReadonlyMap'},
{name: 'get', signatures: [['key']], receiver: 'WeakMap'},
{
name: 'get',
signatures: [['target', 'p', 'receiver']],
receiver: 'ProxyHandler',
},
{
name: 'get',
signatures: [['property']],
receiver: 'StylePropertyMapReadOnly',
},
{name: 'get', signatures: [['key']], receiver: 'Headers'},
{name: 'get', signatures: [['name']], receiver: 'CustomElementRegistry'},
{name: 'get', signatures: [['name']], receiver: 'FormData'},
{name: 'get', signatures: [['name']], receiver: 'URLSearchParams'},
{name: 'get', signatures: [['id']], receiver: 'BackgroundFetchManager'},
{
name: 'get',
signatures: [['name'], ['?options']],
receiver: 'CookieStore',
},
{name: 'get', signatures: [['?options']], receiver: 'CredentialsContainer'},
{name: 'get', signatures: [['keyId']], receiver: 'MediaKeyStatusMap'},
{name: 'get', signatures: [['key']], receiver: 'IDBIndex'},
{name: 'get', signatures: [['key']], receiver: 'IDBObjectStore'},
{
name: 'get',
signatures: [['instrumentKey']],
receiver: 'PaymentInstruments',
},
{name: 'get', signatures: [['id']], receiver: 'Clients'},
{name: 'has', signatures: [['key']], receiver: 'Map'},
{name: 'has', signatures: [['key']], receiver: 'ReadonlyMap'},
{name: 'has', signatures: [['key']], receiver: 'WeakMap'},
{name: 'has', signatures: [['value']], receiver: 'Set'},
{name: 'has', signatures: [['value']], receiver: 'ReadonlySet'},
{name: 'has', signatures: [['value']], receiver: 'WeakSet'},
{name: 'has', signatures: [['target', 'p']], receiver: 'ProxyHandler'},
{
name: 'has',
signatures: [['property']],
receiver: 'StylePropertyMapReadOnly',
},
{name: 'has', signatures: [['key']], receiver: 'Headers'},
{name: 'has', signatures: [['name']], receiver: 'FormData'},
{name: 'has', signatures: [['name']], receiver: 'URLSearchParams'},
{name: 'has', signatures: [['cacheName']], receiver: 'CacheStorage'},
{name: 'has', signatures: [['keyId']], receiver: 'MediaKeyStatusMap'},
{
name: 'has',
signatures: [['instrumentKey']],
receiver: 'PaymentInstruments',
},
{name: 'set', signatures: [['key', 'value']], receiver: 'Map'},
{name: 'set', signatures: [['key', 'value']], receiver: 'WeakMap'},
{
name: 'set',
signatures: [['target', 'p', 'value', 'receiver']],
receiver: 'ProxyHandler',
},
{name: 'set', signatures: [['v']], receiver: 'PropertyDescriptor'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Int8Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Uint8Array'},
{
name: 'set',
signatures: [['array', '?offset']],
receiver: 'Uint8ClampedArray',
},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Int16Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Uint16Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Int32Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Uint32Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Float32Array'},
{name: 'set', signatures: [['array', '?offset']], receiver: 'Float64Array'},
{
name: 'set',
signatures: [['property', '...values']],
receiver: 'StylePropertyMap',
},
{name: 'set', signatures: [['key', 'value']], receiver: 'Headers'},
{
name: 'set',
signatures: [['name', 'value', '?filename']],
receiver: 'FormData',
},
{name: 'set', signatures: [['name', 'value']], receiver: 'URLSearchParams'},
{
name: 'set',
signatures: [['options'], ['name', 'value', '?options']],
receiver: 'CookieStore',
},
{
name: 'set',
signatures: [['instrumentKey', 'details']],
receiver: 'PaymentInstruments',
},
{name: 'add', signatures: [['value']], receiver: 'Set'},
{name: 'add', signatures: [['value']], receiver: 'WeakSet'},
{
name: 'add',
signatures: [['typedArray', 'index', 'value']],
receiver: 'Atomics',
},
{
name: 'add',
signatures: [['node', '?before']],
receiver: 'AccessibleNodeList',
},
{
name: 'add',
signatures: [['file'], ['data', 'type']],
receiver: 'DataTransferItemList',
},
{name: 'add', signatures: [['...values']], receiver: 'CSSNumericValue'},
{name: 'add', signatures: [['...tokens']], receiver: 'DOMTokenList'},
{
name: 'add',
signatures: [['element', '?before']],
receiver: 'HTMLOptionsCollection',
},
{
name: 'add',
signatures: [['element', '?before']],
receiver: 'HTMLSelectElement',
},
{name: 'add', signatures: [['request']], receiver: 'Cache'},
{name: 'add', signatures: [['description']], receiver: 'ContentIndex'},
{name: 'add', signatures: [['value', '?key']], receiver: 'IDBObjectStore'},
{name: 'all', signatures: [['values']]},
{name: 'race', signatures: [['values']]},
{name: 'reject', signatures: [['?reason']]},
{name: 'resolve', signatures: [['?value']]},
{name: 'for', signatures: [['key']]},
{name: 'keyFor', signatures: [['sym']]},
{name: 'next', signatures: [['?value']], receiver: 'Iterator'},
{name: 'next', signatures: [['?value']], receiver: 'AsyncIterator'},
{name: 'return', signatures: [['?value']]},
{name: 'throw', signatures: [['?e']]},
{name: 'entries', signatures: [['o']], static: true, receiver: 'Object'},
{name: 'keys', signatures: [['o']], static: true, receiver: 'Object'},
{name: 'keys', signatures: [['?request', '?options']], receiver: 'Cache'},
{name: 'values', signatures: [['o']], static: true, receiver: 'Object'},
{
name: 'getPrototypeOf',
signatures: [['target']],
receiver: 'ProxyHandler',
},
{
name: 'getPrototypeOf',
signatures: [['o']],
static: true,
receiver: 'Object',
},
{name: 'isExtensible', signatures: [['target']], receiver: 'ProxyHandler'},
{
name: 'isExtensible',
signatures: [['o']],
static: true,
receiver: 'Object',
},
{
name: 'preventExtensions',
signatures: [['target']],
receiver: 'ProxyHandler',
},
{
name: 'preventExtensions',
signatures: [['o']],
static: true,
receiver: 'Object',
},
{
name: 'getOwnPropertyDescriptor',
signatures: [['target', 'p']],
receiver: 'ProxyHandler',
},
{
name: 'getOwnPropertyDescriptor',
signatures: [['o', 'p']],
static: true,
receiver: 'Object',
},
{name: 'deleteProperty', signatures: [['target', 'p']]},
{
name: 'defineProperty',
signatures: [['target', 'p', 'attributes']],
receiver: 'ProxyHandler',
},
{
name: 'defineProperty',
signatures: [['o', 'p', 'attributes']],
static: true,
receiver: 'Object',
},
{name: 'enumerate', signatures: [['target']]},
{name: 'ownKeys', signatures: [['target']]},
{
name: 'apply',
signatures: [['target', 'thisArg', '?argArray']],
receiver: 'ProxyHandler',
},
{
name: 'apply',
signatures: [['thisArg', '?argArray']],
receiver: 'Function',
},
{name: 'construct', signatures: [['target', 'argArray', '?newTarget']]},
{name: 'revocable', signatures: [['target', 'handler']]},
{name: 'match', signatures: [['matcher'], ['regexp']], receiver: 'String'},
{
name: 'match',
signatures: [['request', '?options']],
receiver: 'BackgroundFetchRegistration',
},
{
name: 'match',
signatures: [['request', '?options']],
receiver: 'CacheStorage',
},
{name: 'match', signatures: [['request', '?options']], receiver: 'Cache'},
{
name: 'replace',
signatures: [
['searchValue', 'replaceValue'],
['searchValue', 'replacer'],
],
receiver: 'String',
},
{name: 'replace', signatures: [['text']], receiver: 'CSSStyleSheet'},
{
name: 'replace',
signatures: [['token', 'newToken']],
receiver: 'DOMTokenList',
},
{name: 'replace', signatures: [['url']], receiver: 'Location'},
{name: 'search', signatures: [['searcher'], ['regexp']]},
{
name: 'split',
signatures: [
['splitter', '?limit'],
['separator', '?limit'],
],
},
{name: 'eval', signatures: [['x']]},
{name: 'decodeURI', signatures: [['encodedURI']]},
{name: 'decodeURIComponent', signatures: [['encodedURIComponent']]},
{name: 'encodeURI', signatures: [['uri']]},
{name: 'encodeURIComponent', signatures: [['uriComponent']]},
{name: 'escape', signatures: [['string']], receiver: 'Window'},
{name: 'escape', signatures: [['ident']], static: true, receiver: 'CSS'},
{name: 'unescape', signatures: [['string']]},
{name: 'toString', signatures: [['?radix']], receiver: 'Number'},
{
name: 'toLocaleString',
signatures: [['?locales', '?options']],
receiver: 'Date',
},
{
name: 'toLocaleString',
signatures: [['?locales', '?options']],
receiver: 'Number',
},
{name: 'hasOwnProperty', signatures: [['v']]},
{name: 'isPrototypeOf', signatures: [['v']]},
{name: 'propertyIsEnumerable', signatures: [['v']]},
{name: 'getOwnPropertyNames', signatures: [['o']]},
{
name: 'create',
signatures: [['o', '?properties']],
static: true,
receiver: 'Object',
},
{
name: 'create',
signatures: [['?options']],
receiver: 'CredentialsContainer',
},
{name: 'defineProperties', signatures: [['o', 'properties']]},
{name: 'seal', signatures: [['o']]},
{name: 'freeze', signatures: [['a'], ['f'], ['o']]},
{name: 'isSealed', signatures: [['o']]},
{name: 'isFrozen', signatures: [['o']]},
{name: 'call', signatures: [['thisArg', '...argArray']]},
{name: 'bind', signatures: [['thisArg', '...argArray']]},
{name: 'charAt', signatures: [['pos']]},
{name: 'charCodeAt', signatures: [['index']]},
{name: 'concat', signatures: [['...strings']], receiver: 'String'},
{name: 'concat', signatures: [['...items']], receiver: 'ReadonlyArray'},
{name: 'concat', signatures: [['...items']], receiver: 'Array'},
{
name: 'indexOf',
signatures: [['searchString', '?position']],
receiver: 'String',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'ReadonlyArray',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int8Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8ClampedArray',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int16Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint16Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int32Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint32Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float32Array',
},
{
name: 'indexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float64Array',
},
{
name: 'lastIndexOf',
signatures: [['searchString', '?position']],
receiver: 'String',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'ReadonlyArray',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int8Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint8ClampedArray',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int16Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint16Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Int32Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Uint32Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float32Array',
},
{
name: 'lastIndexOf',
signatures: [['searchElement', '?fromIndex']],
receiver: 'Float64Array',
},
{name: 'localeCompare', signatures: [['that', '?locales', '?options']]},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'String'},
{
name: 'slice',
signatures: [['?start', '?end']],
receiver: 'ReadonlyArray',
},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'ConcatArray'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Array'},
{name: 'slice', signatures: [['begin', '?end']], receiver: 'ArrayBuffer'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Int8Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Uint8Array'},
{
name: 'slice',
signatures: [['?start', '?end']],
receiver: 'Uint8ClampedArray',
},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Int16Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Uint16Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Int32Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Uint32Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Float32Array'},
{name: 'slice', signatures: [['?start', '?end']], receiver: 'Float64Array'},
{
name: 'slice',
signatures: [['?begin', '?end']],
receiver: 'SharedArrayBuffer',
},
{
name: 'slice',
signatures: [['?start', '?end', '?contentType']],
receiver: 'Blob',
},
{name: 'substring', signatures: [['start', '?end']]},
{name: 'substr', signatures: [['from', '?length']]},
{name: 'fromCharCode', signatures: [['...codes']]},
{name: 'toFixed', signatures: [['?fractionDigits']]},
{name: 'toExponential', signatures: [['?fractionDigits']]},
{name: 'toPrecision', signatures: [['?precision']]},
{name: 'abs', signatures: [['x']]},
{name: 'acos', signatures: [['x']]},
{name: 'asin', signatures: [['x']]},
{name: 'atan', signatures: [['x']]},
{name: 'atan2', signatures: [['y', 'x']]},
{name: 'ceil', signatures: [['x']]},
{name: 'cos', signatures: [['x']]},
{name: 'exp', signatures: [['x']]},
{name: 'floor', signatures: [['x']]},
{name: 'log', signatures: [['x']], receiver: 'Math'},
{
name: 'log',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{name: 'log', signatures: [['...data']], receiver: 'console'},
{name: 'max', signatures: [['...values']]},
{name: 'min', signatures: [['...values']]},
{name: 'pow', signatures: [['x', 'y']]},
{name: 'round', signatures: [['x']]},
{name: 'sin', signatures: [['x']]},
{name: 'sqrt', signatures: [['x']]},
{name: 'tan', signatures: [['x']]},
{name: 'toLocaleDateString', signatures: [['?locales', '?options']]},
{name: 'toLocaleTimeString', signatures: [['?locales', '?options']]},
{name: 'setTime', signatures: [['time']]},
{name: 'setMilliseconds', signatures: [['ms']]},
{name: 'setUTCMilliseconds', signatures: [['ms']]},
{name: 'setSeconds', signatures: [['sec', '?ms']]},
{name: 'setUTCSeconds', signatures: [['sec', '?ms']]},
{name: 'setMinutes', signatures: [['min', '?sec', '?ms']]},
{name: 'setUTCMinutes', signatures: [['min', '?sec', '?ms']]},
{name: 'setHours', signatures: [['hours', '?min', '?sec', '?ms']]},
{name: 'setUTCHours', signatures: [['hours', '?min', '?sec', '?ms']]},
{name: 'setDate', signatures: [['date']]},
{name: 'setUTCDate', signatures: [['date']]},
{name: 'setMonth', signatures: [['month', '?date']]},
{name: 'setUTCMonth', signatures: [['month', '?date']]},
{name: 'setFullYear', signatures: [['year', '?month', '?date']]},
{name: 'setUTCFullYear', signatures: [['year', '?month', '?date']]},
{name: 'toJSON', signatures: [['?key']], receiver: 'Date'},
{name: 'parse', signatures: [['s']], static: true, receiver: 'Date'},
{name: 'parse', signatures: [['text', '?reviver']], receiver: 'JSON'},
{
name: 'parse',
signatures: [['cssText']],
static: true,
receiver: 'CSSNumericValue',
},
{
name: 'UTC',
signatures: [
['year', 'month', '?date', '?hours', '?minutes', '?seconds', '?ms'],
],
},
{name: 'exec', signatures: [['string']]},
{name: 'test', signatures: [['string']]},
{name: 'stringify', signatures: [['value', '?replacer', '?space']]},
{name: 'join', signatures: [['?separator']]},
{name: 'every', signatures: [['callbackfn', '?thisArg']]},
{name: 'some', signatures: [['callbackfn', '?thisArg']]},
{name: 'map', signatures: [['callbackfn', '?thisArg']]},
{name: 'filter', signatures: [['callbackfn', '?thisArg']]},
{name: 'reduce', signatures: [['callbackfn', '?initialValue']]},
{name: 'reduceRight', signatures: [['callbackfn', '?initialValue']]},
{name: 'push', signatures: [['...items']]},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Int8Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Uint8Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Uint8ClampedArray'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Int16Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Uint16Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Int32Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Uint32Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Float32Array'},
{name: 'sort', signatures: [['?compareFn']], receiver: 'Float64Array'},
{name: 'splice', signatures: [['start', '?deleteCount', '...items']]},
{name: 'unshift', signatures: [['...items']]},
{name: 'isArray', signatures: [['arg']]},
{name: 'then', signatures: [['?onfulfilled', '?onrejected']]},
{name: 'catch', signatures: [['?onrejected']]},
{name: 'isView', signatures: [['arg']]},
{name: 'getFloat32', signatures: [['byteOffset', '?littleEndian']]},
{name: 'getFloat64', signatures: [['byteOffset', '?littleEndian']]},
{name: 'getInt8', signatures: [['byteOffset']]},
{name: 'getInt16', signatures: [['byteOffset', '?littleEndian']]},
{name: 'getInt32', signatures: [['byteOffset', '?littleEndian']]},
{name: 'getUint8', signatures: [['byteOffset']]},
{name: 'getUint16', signatures: [['byteOffset', '?littleEndian']]},
{name: 'getUint32', signatures: [['byteOffset', '?littleEndian']]},
{
name: 'setFloat32',
signatures: [['byteOffset', 'value', '?littleEndian']],
},
{
name: 'setFloat64',
signatures: [['byteOffset', 'value', '?littleEndian']],
},
{name: 'setInt8', signatures: [['byteOffset', 'value']]},
{name: 'setInt16', signatures: [['byteOffset', 'value', '?littleEndian']]},
{name: 'setInt32', signatures: [['byteOffset', 'value', '?littleEndian']]},
{name: 'setUint8', signatures: [['byteOffset', 'value']]},
{name: 'setUint16', signatures: [['byteOffset', 'value', '?littleEndian']]},
{name: 'setUint32', signatures: [['byteOffset', 'value', '?littleEndian']]},
{name: 'subarray', signatures: [['begin', '?end']]},
{name: 'getOwnPropertyDescriptors', signatures: [['o']]},
{name: 'and', signatures: [['typedArray', 'index', 'value']]},
{
name: 'compareExchange',
signatures: [['typedArray', 'index', 'expectedValue', 'replacementValue']],
},
{name: 'exchange', signatures: [['typedArray', 'index', 'value']]},
{name: 'isLockFree', signatures: [['size']]},
{name: 'load', signatures: [['typedArray', 'index']], receiver: 'Atomics'},
{name: 'load', signatures: [['font', '?text']], receiver: 'FontFaceSet'},
{name: 'load', signatures: [['sessionId']], receiver: 'MediaKeySession'},
{name: 'or', signatures: [['typedArray', 'index', 'value']]},
{
name: 'store',
signatures: [['typedArray', 'index', 'value']],
receiver: 'Atomics',
},
{
name: 'store',
signatures: [['credential']],
receiver: 'CredentialsContainer',
},
{name: 'wait', signatures: [['typedArray', 'index', 'value', '?timeout']]},
{name: 'wake', signatures: [['typedArray', 'index', 'count']]},
{name: 'xor', signatures: [['typedArray', 'index', 'value']]},
{name: 'padStart', signatures: [['maxLength', '?fillString']]},
{name: 'padEnd', signatures: [['maxLength', '?fillString']]},
{name: 'finally', signatures: [['?onfinally']]},
{name: 'flatMap', signatures: [['callback', '?thisArg']]},
{name: 'flatten', signatures: [['?depth']]},
{name: 'getKeys', signatures: [['node']]},
{name: 'unionWith', signatures: [['keys']]},
{name: 'validate', signatures: [['instance', 'schema']]},
{
name: 'checkPropertyChange',
signatures: [['value', 'schema', 'property']],
},
{name: 'mustBeValid', signatures: [['result']]},
{name: 'throwError', signatures: [['err']]},
{name: 'setup', signatures: [['?opts']]},
{
name: 'assert',
signatures: [['value', '?message', '...optionalParams']],
receiver: 'Console',
},
{
name: 'assert',
signatures: [['?condition', '...data']],
receiver: 'console',
},
{name: 'count', signatures: [['?label']], receiver: 'Console'},
{name: 'count', signatures: [['?key']], receiver: 'IDBIndex'},
{name: 'count', signatures: [['?key']], receiver: 'IDBObjectStore'},
{name: 'count', signatures: [['?label']], receiver: 'console'},
{name: 'countReset', signatures: [['?label']]},
{
name: 'debug',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{name: 'debug', signatures: [['...data']], receiver: 'console'},
{name: 'dir', signatures: [['obj', '?options']], receiver: 'Console'},
{name: 'dir', signatures: [['item', '?options']], receiver: 'console'},
{name: 'dirxml', signatures: [['...data']]},
{
name: 'error',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{
name: 'error',
signatures: [['?e']],
receiver: 'ReadableStreamDefaultController',
},
{
name: 'error',
signatures: [['?reason']],
receiver: 'TransformStreamDefaultController',
},
{
name: 'error',
signatures: [['?e']],
receiver: 'WritableStreamDefaultController',
},
{name: 'error', signatures: [['...data']], receiver: 'console'},
{name: 'group', signatures: [['...label']], receiver: 'Console'},
{name: 'group', signatures: [['...data']], receiver: 'console'},
{name: 'groupCollapsed', signatures: [['...label']], receiver: 'Console'},
{name: 'groupCollapsed', signatures: [['...data']], receiver: 'console'},
{
name: 'info',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{name: 'info', signatures: [['...data']], receiver: 'console'},
{
name: 'table',
signatures: [['tabularData', '?properties']],
receiver: 'Console',
},
{name: 'table', signatures: [['...tabularData']], receiver: 'console'},
{name: 'time', signatures: [['?label']]},
{name: 'timeEnd', signatures: [['?label']]},
{name: 'timeLog', signatures: [['?label', '...data']]},
{
name: 'trace',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{name: 'trace', signatures: [['...data']], receiver: 'console'},
{
name: 'warn',
signatures: [['?message', '...optionalParams']],
receiver: 'Console',
},
{name: 'warn', signatures: [['...data']], receiver: 'console'},
{name: 'markTimeline', signatures: [['?label']]},
{name: 'profile', signatures: [['?label']], receiver: 'Console'},
{name: 'profile', signatures: [['options']], receiver: 'Performance'},
{name: 'profile', signatures: [['?title']], receiver: 'console'},
{name: 'profileEnd', signatures: [['?label']], receiver: 'Console'},
{name: 'profileEnd', signatures: [['?title']], receiver: 'console'},
{name: 'timeStamp', signatures: [['?label']], receiver: 'Console'},
{name: 'timeStamp', signatures: [['?name']], receiver: 'console'},
{name: 'timeline', signatures: [['?label']]},
{name: 'timelineEnd', signatures: [['?label']]},
{
name: 'captureStackTrace',
signatures: [['targetObject', '?constructorOpt']],
},
{
name: 'setTimeout',
signatures: [['callback', 'ms', '...args']],
receiver: 'Window',
},
{
name: 'setTimeout',
signatures: [['handler', '?timeout', '...arguments']],
receiver: 'WindowOrWorkerGlobalScope',
},
{name: 'clearTimeout', signatures: [['timeoutId']], receiver: 'Window'},
{
name: 'clearTimeout',
signatures: [['?handle']],
receiver: 'WindowOrWorkerGlobalScope',
},
{
name: 'setInterval',
signatures: [['callback', 'ms', '...args']],
receiver: 'Window',
},
{
name: 'setInterval',
signatures: [['handler', '?timeout', '...arguments']],
receiver: 'WindowOrWorkerGlobalScope',
},
{name: 'clearInterval', signatures: [['intervalId']], receiver: 'Window'},
{
name: 'clearInterval',
signatures: [['?handle']],
receiver: 'WindowOrWorkerGlobalScope',
},
{name: 'setImmediate', signatures: [['callback', '...args']]},
{name: 'clearImmediate', signatures: [['immediateId']]},
{name: 'queueMicrotask', signatures: [['callback']]},
{name: 'paths', signatures: [['request']]},
{name: 'animate', signatures: [['keyframes', '?options']]},
{name: 'getAnimations', signatures: [['?options']], receiver: 'Animatable'},
{name: 'updateTiming', signatures: [['?timing']]},
{
name: 'null',
signatures: [['?effect', '?timeline']],
receiver: 'Animation',
},
{name: 'null', signatures: [['?options']], receiver: 'DocumentTimeline'},
{
name: 'null',
signatures: [['source'], ['target', 'keyframes', '?options']],
receiver: 'KeyframeEffect',
},
{name: 'null', signatures: [['?options']], receiver: 'ScrollTimeline'},
{
name: 'null',
signatures: [['?nodes'], ['index', 'node']],
receiver: 'AccessibleNodeList',
},
{name: 'null', signatures: [['index']], receiver: 'DataTransferItemList'},
{name: 'null', signatures: [['index']], receiver: 'CSSKeyframesRule'},
{
name: 'null',
signatures: [['name'], ['property', 'propertyValue']],
receiver: 'CSSStyleDeclaration',
},
{name: 'null', signatures: [['?options']], receiver: 'CSSStyleSheet'},
{name: 'null', signatures: [['keyword']], receiver: 'CSSKeywordValue'},
{name: 'null', signatures: [['arg']], receiver: 'CSSMathInvert'},
{name: 'null', signatures: [['...args']], receiver: 'CSSMathMax'},
{name: 'null', signatures: [['...args']], receiver: 'CSSMathMin'},
{name: 'null', signatures: [['arg']], receiver: 'CSSMathNegate'},
{name: 'null', signatures: [['...args']], receiver: 'CSSMathProduct'},
{name: 'null', signatures: [['...args']], receiver: 'CSSMathSum'},
{
name: 'null',
signatures: [['matrix', '?options']],
receiver: 'CSSMatrixComponent',
},
{name: 'null', signatures: [['index']], receiver: 'CSSNumericArray'},
{name: 'null', signatures: [['length']], receiver: 'CSSPerspective'},
{name: 'null', signatures: [['x', 'y']], receiver: 'CSSPositionValue'},
{
name: 'null',
signatures: [['angleValue'], ['x', 'y', 'z', 'angle']],
receiver: 'CSSRotate',
},
{name: 'null', signatures: [['x', 'y', '?z']], receiver: 'CSSScale'},
{name: 'null', signatures: [['ax']], receiver: 'CSSSkewX'},
{name: 'null', signatures: [['ay']], receiver: 'CSSSkewY'},
{name: 'null', signatures: [['ax', 'ay']], receiver: 'CSSSkew'},
{
name: 'null',
signatures: [['transforms'], ['index', '?val']],
receiver: 'CSSTransformValue',
},
{name: 'null', signatures: [['x', 'y', '?z']], receiver: 'CSSTranslate'},
{name: 'null', signatures: [['value', 'unit']], receiver: 'CSSUnitValue'},
{
name: 'null',
signatures: [['members'], ['index', '?val']],
receiver: 'CSSUnparsedValue',
},
{
name: 'null',
signatures: [['variable', '?fallback']],
receiver: 'CSSVariableReferenceValue',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'FontFaceSetLoadEvent',
},
{
name: 'null',
signatures: [['family', 'source', '?descriptors']],
receiver: 'FontFace',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MediaQueryListEvent',
},
{name: 'null', signatures: [['name']], receiver: 'StyleSheetList'},
{name: 'null', signatures: [['?data']], receiver: 'Comment'},
{
name: 'null',
signatures: [['?message', '?name']],
receiver: 'DOMException',
},
{name: 'null', signatures: [['name', '?value']], receiver: 'DOMStringMap'},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'CustomEvent',
},
{name: 'null', signatures: [['type', '?eventInitDict']], receiver: 'Event'},
{name: 'null', signatures: [['callback']], receiver: 'MutationObserver'},
{name: 'null', signatures: [['?data']], receiver: 'Text'},
{name: 'null', signatures: [['?options']], receiver: 'EditContext'},
{
name: 'null',
signatures: [['?options']],
receiver: 'TextFormatUpdateEvent',
},
{name: 'null', signatures: [['?options']], receiver: 'TextUpdateEvent'},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'AnimationEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'AnimationPlaybackEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'ClipboardEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'CompositionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'DragEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'ErrorEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'FocusEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'HashChangeEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'InputEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'KeyboardEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MessageEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MouseEvent',
},
{
name: 'null',
signatures: [['type', 'bubbles', '?eventInitDict']],
receiver: 'OverscrollEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PageTransitionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PointerEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PopStateEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'ProgressEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'PromiseRejectionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'SecurityPolicyViolationEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'TouchEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'TransitionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'UIEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'WheelEvent',
},
{name: 'null', signatures: [['?init']], receiver: 'Headers'},
{
name: 'null',
signatures: [['input', '?requestInitDict']],
receiver: 'Request',
},
{name: 'null', signatures: [['?body', '?init']], receiver: 'Response'},
{name: 'null', signatures: [['?blobParts', '?options']], receiver: 'Blob'},
{
name: 'null',
signatures: [['fileBits', 'fileName', '?options']],
receiver: 'File',
},
{
name: 'null',
signatures: [['callback', '?options']],
receiver: 'ReportingObserver',
},
{name: 'null', signatures: [['index'], ['name']], receiver: 'Window'},
{name: 'null', signatures: [['?init']], receiver: 'DOMMatrixReadOnly'},
{name: 'null', signatures: [['?init']], receiver: 'DOMMatrix'},
{
name: 'null',
signatures: [['?x', '?y', '?z', '?w']],
receiver: 'DOMPointReadOnly',
},
{
name: 'null',
signatures: [['?x', '?y', '?z', '?w']],
receiver: 'DOMPoint',
},
{
name: 'null',
signatures: [['?p1', '?p2', '?p3', '?p4']],
receiver: 'DOMQuad',
},
{
name: 'null',
signatures: [['?x', '?y', '?width', '?height']],
receiver: 'DOMRectReadOnly',
},
{
name: 'null',
signatures: [['?x', '?y', '?width', '?height']],
receiver: 'DOMRect',
},
{
name: 'null',
signatures: [
['sw', 'sh'],
['data', 'sw', '?sh'],
],
receiver: 'ImageData',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'FormDataEvent',
},
{name: 'null', signatures: [['?form']], receiver: 'FormData'},
{
name: 'null',
signatures: [['index']],
receiver: 'HTMLFormControlsCollection',
},
{
name: 'null',
signatures: [['index'], ['name']],
receiver: 'HTMLFormElement',
},
{
name: 'null',
signatures: [['index', '?option'], ['name']],
receiver: 'HTMLOptionsCollection',
},
{
name: 'null',
signatures: [['index', 'option']],
receiver: 'HTMLSelectElement',
},
{name: 'null', signatures: [['index']], receiver: 'RadioNodeList'},
{name: 'null', signatures: [['index']], receiver: 'HTMLAllCollection'},
{
name: 'null',
signatures: [['name', '?value']],
receiver: 'HTMLEmbedElement',
},
{
name: 'null',
signatures: [['name', '?value']],
receiver: 'HTMLObjectElement',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PortalActivateEvent',
},
{name: 'null', signatures: [['index']], receiver: 'AudioTrackList'},
{name: 'null', signatures: [['index']], receiver: 'TextTrackCueList'},
{name: 'null', signatures: [['index']], receiver: 'TextTrackList'},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'TrackEvent',
},
{name: 'null', signatures: [['index']], receiver: 'VideoTrackList'},
{
name: 'null',
signatures: [['startTime', 'endTime', 'text']],
receiver: 'VTTCue',
},
{
name: 'null',
signatures: [['?deviceInitDict']],
receiver: 'InputDeviceCapabilities',
},
{name: 'null', signatures: [['initDict']], receiver: 'Touch'},
{
name: 'null',
signatures: [['callback', '?options']],
receiver: 'IntersectionObserver',
},
{
name: 'null',
signatures: [['interfaceName', '?scope', '?useBrowserInterfaceBroker']],
receiver: 'MojoInterfaceInterceptor',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MojoInterfaceRequestEvent',
},
{
name: 'null',
signatures: [['width', 'height']],
receiver: 'OffscreenCanvas',
},
{name: 'null', signatures: [['?scrollStateInit']], receiver: 'ScrollState'},
{name: 'null', signatures: [['callback']], receiver: 'ResizeObserver'},
{
name: 'null',
signatures: [['init']],
receiver: 'ByteLengthQueuingStrategy',
},
{name: 'null', signatures: [['init']], receiver: 'CountQueuingStrategy'},
{
name: 'null',
signatures: [['?underlyingSource', '?strategy']],
receiver: 'ReadableStream',
},
{
name: 'null',
signatures: [['?transformer', '?writableStrategy', '?readableStrategy']],
receiver: 'TransformStream',
},
{
name: 'null',
signatures: [['?underlyingSink', '?strategy']],
receiver: 'WritableStream',
},
{
name: 'null',
signatures: [['index', 'newItem']],
receiver: 'SVGLengthList',
},
{
name: 'null',
signatures: [['index', 'newItem']],
receiver: 'SVGNumberList',
},
{
name: 'null',
signatures: [['index', 'newItem']],
receiver: 'SVGPointList',
},
{
name: 'null',
signatures: [['index', 'newItem']],
receiver: 'SVGStringList',
},
{
name: 'null',
signatures: [['index', 'newItem']],
receiver: 'SVGTransformList',
},
{
name: 'null',
signatures: [['markName', '?markOptions']],
receiver: 'PerformanceMark',
},
{name: 'null', signatures: [['callback']], receiver: 'PerformanceObserver'},
{name: 'null', signatures: [['?init']], receiver: 'URLSearchParams'},
{name: 'null', signatures: [['url', '?base']], receiver: 'URL'},
{name: 'null', signatures: [['scriptURL', '?options']], receiver: 'Worker'},
{
name: 'null',
signatures: [['animatorName', 'effects', '?timeline', '?options']],
receiver: 'WorkletAnimation',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'BeforeInstallPromptEvent',
},
{
name: 'null',
signatures: [['type', 'init']],
receiver: 'BackgroundFetchEvent',
},
{
name: 'null',
signatures: [['type', 'init']],
receiver: 'BackgroundFetchUpdateUIEvent',
},
{
name: 'null',
signatures: [['type', 'init']],
receiver: 'PeriodicSyncEvent',
},
{name: 'null', signatures: [['type', 'init']], receiver: 'SyncEvent'},
{name: 'null', signatures: [['name']], receiver: 'BroadcastChannel'},
{name: 'null', signatures: [['?path']], receiver: 'Path2D'},
{name: 'null', signatures: [['format']], receiver: 'CompressionStream'},
{name: 'null', signatures: [['format']], receiver: 'DecompressionStream'},
{
name: 'null',
signatures: [['type', 'init']],
receiver: 'ContentIndexEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'CookieChangeEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'ExtendableCookieChangeEvent',
},
{name: 'null', signatures: [['data']], receiver: 'FederatedCredential'},
{
name: 'null',
signatures: [['data'], ['form']],
receiver: 'PasswordCredential',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'DeviceMotionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'DeviceOrientationEvent',
},
{
name: 'null',
signatures: [['?label', '?options']],
receiver: 'TextDecoderStream',
},
{
name: 'null',
signatures: [['?label', '?options']],
receiver: 'TextDecoder',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MediaEncryptedEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'MediaKeyMessageEvent',
},
{
name: 'null',
signatures: [['url', '?eventSourceInitDict']],
receiver: 'EventSource',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'GamepadAxisEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'GamepadButtonEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'GamepadEvent',
},
{name: 'null', signatures: [['index']], receiver: 'GamepadList'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'HIDConnectionEvent',
},
{name: 'null', signatures: [['?options']], receiver: 'IdleDetector'},
{name: 'null', signatures: [['track']], receiver: 'ImageCapture'},
{name: 'null', signatures: [['callback']], receiver: 'IDBObserver'},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'IDBVersionChangeEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'BlobEvent',
},
{
name: 'null',
signatures: [['stream', '?options']],
receiver: 'MediaRecorder',
},
{name: 'null', signatures: [['?metadata']], receiver: 'MediaMetadata'},
{name: 'null', signatures: [['index']], receiver: 'SourceBufferList'},
{
name: 'null',
signatures: [['?trackDefaults'], ['index']],
receiver: 'TrackDefaultList',
},
{
name: 'null',
signatures: [['type', 'language', 'label', 'kinds', '?byteStreamTrackID']],
receiver: 'TrackDefault',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MediaStreamEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'MediaStreamTrackEvent',
},
{
name: 'null',
signatures: [['?stream'], ['tracks']],
receiver: 'MediaStream',
},
{
name: 'null',
signatures: [['constraint', 'message']],
receiver: 'OverconstrainedError',
},
{name: 'null', signatures: [['messageInit']], receiver: 'NDEFMessage'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'NDEFReadingEvent',
},
{name: 'null', signatures: [['recordInit']], receiver: 'NDEFRecord'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'NotificationEvent',
},
{
name: 'null',
signatures: [['title', '?options']],
receiver: 'Notification',
},
{name: 'null', signatures: [['timestamp']], receiver: 'TimestampTrigger'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'AbortPaymentEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'CanMakePaymentEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MerchantValidationEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PaymentMethodChangeEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'PaymentRequestEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PaymentRequestUpdateEvent',
},
{
name: 'null',
signatures: [['methodData', 'details', '?options']],
receiver: 'PaymentRequest',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'RTCDataChannelEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'RTCDTMFToneChangeEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'RTCErrorEvent',
},
{name: 'null', signatures: [['init', '?message']], receiver: 'RTCError'},
{
name: 'null',
signatures: [['?candidateInitDict']],
receiver: 'RTCIceCandidate',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'RTCPeerConnectionIceErrorEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'RTCPeerConnectionIceEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'RTCQuicStreamEvent',
},
{name: 'null', signatures: [['transport']], receiver: 'RTCQuicTransport'},
{
name: 'null',
signatures: [['?descriptionInitDict']],
receiver: 'RTCSessionDescription',
},
{name: 'null', signatures: [['name']], receiver: 'RTCStatsResponse'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'EnterPictureInPictureEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'PresentationConnectionAvailableEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'PresentationConnectionCloseEvent',
},
{
name: 'null',
signatures: [['url'], ['urls']],
receiver: 'PresentationRequest',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PushEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'PushSubscriptionChangeEvent',
},
{name: 'null', signatures: [['name', '?message']], receiver: 'DOMError'},
{name: 'null', signatures: [['?priority']], receiver: 'TaskController'},
{
name: 'null',
signatures: [['?sensorOptions']],
receiver: 'AbsoluteOrientationSensor',
},
{name: 'null', signatures: [['?sensorOptions']], receiver: 'Accelerometer'},
{
name: 'null',
signatures: [['?sensorOptions']],
receiver: 'AmbientLightSensor',
},
{name: 'null', signatures: [['?sensorOptions']], receiver: 'Gyroscope'},
{
name: 'null',
signatures: [['?sensorOptions']],
receiver: 'LinearAccelerationSensor',
},
{name: 'null', signatures: [['?sensorOptions']], receiver: 'Magnetometer'},
{
name: 'null',
signatures: [['?sensorOptions']],
receiver: 'RelativeOrientationSensor',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'SensorErrorEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'ExtendableEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'FetchEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'InstallEvent',
},
{
name: 'null',
signatures: [['?barcodeDetectorOptions']],
receiver: 'BarcodeDetector',
},
{
name: 'null',
signatures: [['?faceDetectorOptions']],
receiver: 'FaceDetector',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'SpeechRecognitionErrorEvent',
},
{
name: 'null',
signatures: [['type', '?initDict']],
receiver: 'SpeechRecognitionEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'SpeechSynthesisErrorEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'SpeechSynthesisEvent',
},
{
name: 'null',
signatures: [['?text']],
receiver: 'SpeechSynthesisUtterance',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'StorageEvent',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'AnalyserNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'AudioBufferSourceNode',
},
{name: 'null', signatures: [['options']], receiver: 'AudioBuffer'},
{name: 'null', signatures: [['?contextOptions']], receiver: 'AudioContext'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'AudioProcessingEvent',
},
{
name: 'null',
signatures: [['context', 'name', '?options']],
receiver: 'AudioWorkletNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'BiquadFilterNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'ChannelMergerNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'ChannelSplitterNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'ConstantSourceNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'ConvolverNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'DelayNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'DynamicsCompressorNode',
},
{name: 'null', signatures: [['context', '?options']], receiver: 'GainNode'},
{
name: 'null',
signatures: [['context', 'options']],
receiver: 'IIRFilterNode',
},
{
name: 'null',
signatures: [['context', 'options']],
receiver: 'MediaElementAudioSourceNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'MediaStreamAudioDestinationNode',
},
{
name: 'null',
signatures: [['context', 'options']],
receiver: 'MediaStreamAudioSourceNode',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'OfflineAudioCompletionEvent',
},
{
name: 'null',
signatures: [
['options'],
['numberOfChannels', 'numberOfFrames', 'sampleRate'],
],
receiver: 'OfflineAudioContext',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'OscillatorNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'PannerNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'PeriodicWave',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'StereoPannerNode',
},
{
name: 'null',
signatures: [['context', '?options']],
receiver: 'WaveShaperNode',
},
{
name: 'null',
signatures: [
['type', 'timestamp', 'data'],
['type', 'timestamp', 'duration', 'data'],
],
receiver: 'EncodedVideoChunk',
},
{
name: 'null',
signatures: [['type', '?eventInit']],
receiver: 'WebGLContextEvent',
},
{
name: 'null',
signatures: [['type', 'gpuUncapturedErrorEventInitDict']],
receiver: 'GPUUncapturedErrorEvent',
},
{name: 'null', signatures: [['message']], receiver: 'GPUValidationError'},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MIDIConnectionEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'MIDIMessageEvent',
},
{
name: 'null',
signatures: [['type', '?eventInitDict']],
receiver: 'CloseEvent',
},
{
name: 'null',
signatures: [['url', '?options']],
receiver: 'WebSocketStream',
},
{name: 'null', signatures: [['url', '?protocols']], receiver: 'WebSocket'},
{name: 'null', signatures: [['url']], receiver: 'QuicTransport'},
{
name: 'null',
signatures: [['deviceInterface', 'alternateSetting']],
receiver: 'USBAlternateInterface',
},
{
name: 'null',
signatures: [['device', 'configurationValue']],
receiver: 'USBConfiguration',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'USBConnectionEvent',
},
{
name: 'null',
signatures: [['alternate', 'endpointNumber', 'direction']],
receiver: 'USBEndpoint',
},
{
name: 'null',
signatures: [['status', '?data']],
receiver: 'USBInTransferResult',
},
{
name: 'null',
signatures: [['configuration', 'interfaceNumber']],
receiver: 'USBInterface',
},
{
name: 'null',
signatures: [['status', '?data']],
receiver: 'USBIsochronousInTransferPacket',
},
{
name: 'null',
signatures: [['packets', '?data']],
receiver: 'USBIsochronousInTransferResult',
},
{
name: 'null',
signatures: [['status', '?bytesWritten']],
receiver: 'USBIsochronousOutTransferPacket',
},
{
name: 'null',
signatures: [['packets']],
receiver: 'USBIsochronousOutTransferResult',
},
{
name: 'null',
signatures: [['status', '?bytesWritten']],
receiver: 'USBOutTransferResult',
},
{name: 'null', signatures: [['index']], receiver: 'XRInputSourceArray'},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'XRInputSourceEvent',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'XRInputSourcesChangeEvent',
},
{
name: 'null',
signatures: [['?origin', '?direction'], ['transform']],
receiver: 'XRRay',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'XRReferenceSpaceEvent',
},
{
name: 'null',
signatures: [['?position', '?orientation']],
receiver: 'XRRigidTransform',
},
{
name: 'null',
signatures: [['type', 'eventInitDict']],
receiver: 'XRSessionEvent',
},
{
name: 'null',
signatures: [['session', 'context', '?layerInit']],
receiver: 'XRWebGLLayer',
},
{name: 'updatePlaybackRate', signatures: [['playback_rate']]},
{name: 'cancel', signatures: [['?reason']], receiver: 'ReadableStream'},
{
name: 'cancel',
signatures: [['?reason']],
receiver: 'UnderlyingSourceBase',
},
{name: 'setKeyframes', signatures: [['keyframes']]},
{name: 'item', signatures: [['index']], receiver: 'AccessibleNodeList'},
{name: 'item', signatures: [['index']], receiver: 'CSSRuleList'},
{name: 'item', signatures: [['index']], receiver: 'CSSStyleDeclaration'},
{name: 'item', signatures: [['index']], receiver: 'MediaList'},
{name: 'item', signatures: [['index']], receiver: 'StyleSheetList'},
{name: 'item', signatures: [['index']], receiver: 'DOMStringList'},
{name: 'item', signatures: [['index']], receiver: 'DOMTokenList'},
{name: 'item', signatures: [['index']], receiver: 'NamedNodeMap'},
{name: 'item', signatures: [['index']], receiver: 'NodeList'},
{name: 'item', signatures: [['index']], receiver: 'FileList'},
{name: 'item', signatures: [['index']], receiver: 'DOMRectList'},
{name: 'item', signatures: [['index']], receiver: 'HTMLSelectElement'},
{
name: 'item',
signatures: [['?nameOrIndex']],
receiver: 'HTMLAllCollection',
},
{name: 'item', signatures: [['index']], receiver: 'HTMLCollection'},
{name: 'item', signatures: [['index']], receiver: 'TouchList'},
{name: 'item', signatures: [['?index']], receiver: 'GamepadList'},
{name: 'item', signatures: [['index']], receiver: 'MimeTypeArray'},
{name: 'item', signatures: [['index']], receiver: 'PluginArray'},
{name: 'item', signatures: [['index']], receiver: 'Plugin'},
{name: 'item', signatures: [['index']], receiver: 'SpeechGrammarList'},
{
name: 'item',
signatures: [['index']],
receiver: 'SpeechRecognitionResultList',
},
{
name: 'item',
signatures: [['index']],
receiver: 'SpeechRecognitionResult',
},
{name: 'item', signatures: [['index']], receiver: 'SQLResultSetRowList'},
{name: 'remove', signatures: [['index']], receiver: 'AccessibleNodeList'},
{name: 'remove', signatures: [['index']], receiver: 'DataTransferItemList'},
{name: 'remove', signatures: [['...tokens']], receiver: 'DOMTokenList'},
{
name: 'remove',
signatures: [['index']],
receiver: 'HTMLOptionsCollection',
},
{name: 'remove', signatures: [['?index']], receiver: 'HTMLSelectElement'},
{
name: 'remove',
signatures: [['successCallback', '?errorCallback']],
receiver: 'Entry',
},
{name: 'remove', signatures: [['start', 'end']], receiver: 'SourceBuffer'},
{name: 'appendChild', signatures: [['child']], receiver: 'AccessibleNode'},
{name: 'appendChild', signatures: [['node']], receiver: 'Node'},
{name: 'removeChild', signatures: [['child']]},
{name: 'getAsString', signatures: [['callback']]},
{name: 'setDragImage', signatures: [['image', 'x', 'y']]},
{name: 'getData', signatures: [['format']]},
{name: 'setData', signatures: [['format', 'data']]},
{name: 'clearData', signatures: [['?format']]},
{
name: 'insertRule',
signatures: [['rule', 'index']],
receiver: 'CSSGroupingRule',
},
{
name: 'insertRule',
signatures: [['rule', '?index']],
receiver: 'CSSStyleSheet',
},
{name: 'deleteRule', signatures: [['index']], receiver: 'CSSGroupingRule'},
{
name: 'deleteRule',
signatures: [['select']],
receiver: 'CSSKeyframesRule',
},
{name: 'deleteRule', signatures: [['index']], receiver: 'CSSStyleSheet'},
{name: 'appendRule', signatures: [['rule']]},
{name: 'findRule', signatures: [['select']]},
{name: 'getPropertyValue', signatures: [['property']]},
{name: 'getPropertyPriority', signatures: [['property']]},
{name: 'setProperty', signatures: [['property', 'value', '?priority']]},
{name: 'removeProperty', signatures: [['property']]},
{name: 'replaceSync', signatures: [['text']]},
{name: 'addRule', signatures: [['?selector', '?style', '?index']]},
{name: 'removeRule', signatures: [['?index']]},
{
name: 'supports',
signatures: [['conditionText'], ['property', 'value']],
static: true,
receiver: 'CSS',
},
{name: 'supports', signatures: [['token']], receiver: 'DOMTokenList'},
{name: 'mul', signatures: [['...values']]},
{name: 'div', signatures: [['...values']]},
{name: 'equals', signatures: [['...values']]},
{name: 'to', signatures: [['unit']]},
{name: 'toSum', signatures: [['...units']]},
{name: 'number', signatures: [['value']]},
{name: 'percent', signatures: [['value']]},
{name: 'em', signatures: [['value']]},
{name: 'ex', signatures: [['value']]},
{name: 'ch', signatures: [['value']]},
{name: 'rem', signatures: [['value']]},
{name: 'vw', signatures: [['value']]},
{name: 'vh', signatures: [['value']]},
{name: 'vmin', signatures: [['value']]},
{name: 'vmax', signatures: [['value']]},
{name: 'cm', signatures: [['value']]},
{name: 'mm', signatures: [['value']]},
{name: 'in', signatures: [['value']]},
{name: 'pt', signatures: [['value']]},
{name: 'pc', signatures: [['value']]},
{name: 'px', signatures: [['value']]},
{name: 'Q', signatures: [['value']]},
{name: 'deg', signatures: [['value']]},
{name: 'grad', signatures: [['value']]},
{name: 'rad', signatures: [['value']]},
{name: 'turn', signatures: [['value']]},
{name: 's', signatures: [['value']]},
{name: 'ms', signatures: [['value']]},
{name: 'Hz', signatures: [['value']]},
{name: 'kHz', signatures: [['value']]},
{name: 'dpi', signatures: [['value']]},
{name: 'dpcm', signatures: [['value']]},
{name: 'dppx', signatures: [['value']]},
{name: 'fr', signatures: [['value']]},
{
name: 'getAll',
signatures: [['property']],
receiver: 'StylePropertyMapReadOnly',
},
{name: 'getAll', signatures: [['name']], receiver: 'FormData'},
{name: 'getAll', signatures: [['name']], receiver: 'URLSearchParams'},
{
name: 'getAll',
signatures: [['name'], ['?options']],
receiver: 'CookieStore',
},
{name: 'getAll', signatures: [['?query', '?count']], receiver: 'IDBIndex'},
{
name: 'getAll',
signatures: [['?query', '?count']],
receiver: 'IDBObjectStore',
},
{
name: 'append',
signatures: [['property', '...values']],
receiver: 'StylePropertyMap',
},
{name: 'append', signatures: [['...nodes']], receiver: 'ParentNode'},
{name: 'append', signatures: [['name', 'value']], receiver: 'Headers'},
{
name: 'append',
signatures: [['name', 'value', '?filename']],
receiver: 'FormData',
},
{
name: 'append',
signatures: [['name', 'value']],
receiver: 'URLSearchParams',
},
{name: 'check', signatures: [['font', '?text']]},
{name: 'appendMedium', signatures: [['medium']]},
{name: 'deleteMedium', signatures: [['medium']]},
{name: 'addListener', signatures: [['listener']]},
{name: 'removeListener', signatures: [['listener']]},
{name: 'registerProperty', signatures: [['definition']]},
{name: 'matchMedium', signatures: [['?mediaquery']]},
{name: 'abort', signatures: [['reason']], receiver: 'UnderlyingSinkBase'},
{name: 'abort', signatures: [['?reason']], receiver: 'WritableStream'},
{name: 'substringData', signatures: [['offset', 'count']]},
{name: 'appendData', signatures: [['data']]},
{name: 'insertData', signatures: [['offset', 'data']]},
{name: 'deleteData', signatures: [['offset', 'count']]},
{name: 'replaceData', signatures: [['offset', 'count', 'data']]},
{name: 'before', signatures: [['...nodes']]},
{name: 'after', signatures: [['...nodes']]},
{name: 'replaceWith', signatures: [['...nodes']]},
{name: 'elementFromPoint', signatures: [['x', 'y']]},
{name: 'elementsFromPoint', signatures: [['x', 'y']]},
{name: 'getElementsByTagName', signatures: [['localName']]},
{
name: 'getElementsByTagNameNS',
signatures: [['namespaceURI', 'localName']],
},
{name: 'getElementsByClassName', signatures: [['classNames']]},
{name: 'createElement', signatures: [['localName', '?options']]},
{
name: 'createElementNS',
signatures: [['namespaceURI', 'qualifiedName', '?options']],
},
{name: 'createTextNode', signatures: [['data']]},
{name: 'createCDATASection', signatures: [['data']]},
{name: 'createComment', signatures: [['data']]},
{name: 'createProcessingInstruction', signatures: [['target', 'data']]},
{name: 'importNode', signatures: [['node', '?deep']]},
{name: 'adoptNode', signatures: [['node']]},
{name: 'createAttribute', signatures: [['localName']]},
{
name: 'createAttributeNS',
signatures: [['namespaceURI', 'qualifiedName']],
},
{name: 'createEvent', signatures: [['eventType']]},
{
name: 'createNodeIterator',
signatures: [['root', '?whatToShow', '?filter']],
},
{
name: 'createTreeWalker',
signatures: [['root', '?whatToShow', '?filter']],
},
{name: 'getElementsByName', signatures: [['elementName']]},
{
name: 'open',
signatures: [
['?type', '?replace'],
['url', 'name', 'features'],
],
receiver: 'Document',
},
{
name: 'open',
signatures: [['?url', '?target', '?features']],
receiver: 'Window',
},
{
name: 'open',
signatures: [['method', 'url', '?async', '?username', '?password']],
receiver: 'XMLHttpRequest',
},
{name: 'open', signatures: [['cacheName']], receiver: 'CacheStorage'},
{name: 'open', signatures: [['name', '?version']], receiver: 'IDBFactory'},
{
name: 'close',
signatures: [['?returnValue']],
receiver: 'HTMLDialogElement',
},
{name: 'close', signatures: [['?closeInfo']], receiver: 'WebSocketStream'},
{name: 'close', signatures: [['?code', '?reason']], receiver: 'WebSocket'},
{name: 'close', signatures: [['?closeInfo']], receiver: 'QuicTransport'},
{name: 'write', signatures: [['...text'], ['text']], receiver: 'Document'},
{
name: 'write',
signatures: [['chunk', 'controller']],
receiver: 'UnderlyingSinkBase',
},
{name: 'write', signatures: [['data']], receiver: 'Clipboard'},
{name: 'write', signatures: [['data']], receiver: 'FileWriterSync'},
{name: 'write', signatures: [['data']], receiver: 'FileWriter'},
{
name: 'write',
signatures: [['data']],
receiver: 'FileSystemWritableFileStream',
},
{
name: 'write',
signatures: [['position', 'data']],
receiver: 'FileSystemWriter',
},
{name: 'write', signatures: [['data']], receiver: 'RTCQuicStream'},
{name: 'writeln', signatures: [['...text'], ['text']]},
{name: 'execCommand', signatures: [['commandId', '?showUI', '?value']]},
{name: 'queryCommandEnabled', signatures: [['commandId']]},
{name: 'queryCommandIndeterm', signatures: [['commandId']]},
{name: 'queryCommandState', signatures: [['commandId']]},
{name: 'queryCommandSupported', signatures: [['commandId']]},
{name: 'queryCommandValue', signatures: [['commandId']]},
{name: 'registerElement', signatures: [['type', '?options']]},
{name: 'caretRangeFromPoint', signatures: [['?x', '?y']]},
{
name: 'createDocumentType',
signatures: [['qualifiedName', 'publicId', 'systemId']],
},
{
name: 'createDocument',
signatures: [['namespaceURI', 'qualifiedName', '?doctype']],
},
{name: 'createHTMLDocument', signatures: [['?title']]},
{name: 'contains', signatures: [['string']], receiver: 'DOMStringList'},
{name: 'contains', signatures: [['token']], receiver: 'DOMTokenList'},
{name: 'contains', signatures: [['other']], receiver: 'Node'},
{name: 'toggle', signatures: [['token', '?force']]},
{name: 'getAttribute', signatures: [['name']]},
{name: 'getAttributeNS', signatures: [['namespaceURI', 'localName']]},
{name: 'setAttribute', signatures: [['name', 'value']]},
{name: 'setAttributeNS', signatures: [['namespaceURI', 'name', 'value']]},
{name: 'removeAttribute', signatures: [['name']]},
{name: 'removeAttributeNS', signatures: [['namespaceURI', 'localName']]},
{name: 'toggleAttribute', signatures: [['qualifiedName', '?force']]},
{name: 'hasAttribute', signatures: [['name']]},
{name: 'hasAttributeNS', signatures: [['namespaceURI', 'localName']]},
{name: 'getAttributeNode', signatures: [['name']]},
{name: 'getAttributeNodeNS', signatures: [['namespaceURI', 'localName']]},
{name: 'setAttributeNode', signatures: [['attr']]},
{name: 'setAttributeNodeNS', signatures: [['attr']]},
{name: 'removeAttributeNode', signatures: [['attr']]},
{name: 'attachShadow', signatures: [['shadowRootInitDict']]},
{name: 'closest', signatures: [['selectors']]},
{name: 'matches', signatures: [['selectors']]},
{name: 'webkitMatchesSelector', signatures: [['selectors']]},
{name: 'insertAdjacentElement', signatures: [['where', 'element']]},
{name: 'insertAdjacentText', signatures: [['where', 'data']]},
{name: 'setPointerCapture', signatures: [['pointerId']]},
{name: 'releasePointerCapture', signatures: [['pointerId']]},
{name: 'hasPointerCapture', signatures: [['pointerId']]},
{name: 'insertAdjacentHTML', signatures: [['position', 'text']]},
{name: 'requestPointerLock', signatures: [['?options']]},
{name: 'scrollIntoView', signatures: [['?arg']]},
{name: 'scroll', signatures: [['?options'], ['x', 'y']]},
{name: 'scrollTo', signatures: [['?options'], ['x', 'y']]},
{name: 'scrollBy', signatures: [['?options'], ['x', 'y']]},
{name: 'scrollIntoViewIfNeeded', signatures: [['?centerIfNeeded']]},
{
name: 'initCustomEvent',
signatures: [['type', '?bubbles', '?cancelable', '?detail']],
},
{name: 'handleEvent', signatures: [['event']], receiver: 'EventListener'},
{
name: 'handleEvent',
signatures: [['entries']],
receiver: 'EntriesCallback',
},
{name: 'handleEvent', signatures: [['entry']], receiver: 'EntryCallback'},
{name: 'handleEvent', signatures: [['error']], receiver: 'ErrorCallback'},
{name: 'handleEvent', signatures: [['file']], receiver: 'FileCallback'},
{
name: 'handleEvent',
signatures: [['fileSystem']],
receiver: 'FileSystemCallback',
},
{
name: 'handleEvent',
signatures: [['fileWriter']],
receiver: 'FileWriterCallback',
},
{
name: 'handleEvent',
signatures: [['metadata']],
receiver: 'MetadataCallback',
},
{
name: 'handleEvent',
signatures: [['transaction', 'resultSet']],
receiver: 'SQLStatementCallback',
},
{
name: 'handleEvent',
signatures: [['transaction', 'error']],
receiver: 'SQLStatementErrorCallback',
},
{
name: 'handleEvent',
signatures: [['transaction']],
receiver: 'SQLTransactionCallback',
},
{
name: 'handleEvent',
signatures: [['error']],
receiver: 'SQLTransactionErrorCallback',
},
{name: 'addEventListener', signatures: [['type', 'listener', '?options']]},
{
name: 'removeEventListener',
signatures: [['type', 'listener', '?options']],
},
{name: 'dispatchEvent', signatures: [['event']]},
{name: 'initEvent', signatures: [['type', '?bubbles', '?cancelable']]},
{
name: 'observe',
signatures: [['target', '?options']],
receiver: 'MutationObserver',
},
{
name: 'observe',
signatures: [['target']],
receiver: 'IntersectionObserver',
},
{name: 'observe', signatures: [['target']], receiver: 'ResizeObserver'},
{
name: 'observe',
signatures: [['?options']],
receiver: 'PerformanceObserver',
},
{
name: 'observe',
signatures: [['db', 'tx', 'options']],
receiver: 'IDBObserver',
},
{
name: 'disconnect',
signatures: [['?output'], ['destination', '?output', '?input']],
receiver: 'AudioNode',
},
{name: 'getNamedItem', signatures: [['name']]},
{name: 'getNamedItemNS', signatures: [['namespaceURI', 'localName']]},
{name: 'setNamedItem', signatures: [['attr']]},
{name: 'setNamedItemNS', signatures: [['attr']]},
{name: 'removeNamedItem', signatures: [['name']]},
{name: 'removeNamedItemNS', signatures: [['namespaceURI', 'localName']]},
{name: 'acceptNode', signatures: [['node']]},
{
name: 'setApplyScroll',
signatures: [['scrollStateCallback', 'nativeScrollBehavior']],
},
{
name: 'setDistributeScroll',
signatures: [['scrollStateCallback', 'nativeScrollBehavior']],
},
{name: 'getRootNode', signatures: [['?options']]},
{name: 'cloneNode', signatures: [['?deep']]},
{name: 'isEqualNode', signatures: [['otherNode']]},
{name: 'isSameNode', signatures: [['otherNode']]},
{name: 'compareDocumentPosition', signatures: [['other']]},
{name: 'lookupPrefix', signatures: [['namespaceURI']]},
{name: 'lookupNamespaceURI', signatures: [['prefix']], receiver: 'Node'},
{
name: 'lookupNamespaceURI',
signatures: [['?prefix']],
receiver: 'XPathNSResolver',
},
{name: 'isDefaultNamespace', signatures: [['namespaceURI']]},
{name: 'insertBefore', signatures: [['node', 'child']]},
{name: 'replaceChild', signatures: [['node', 'child']]},
{name: 'getElementById', signatures: [['elementId']]},
{name: 'prepend', signatures: [['...nodes']]},
{name: 'querySelector', signatures: [['selectors']]},
{name: 'querySelectorAll', signatures: [['selectors']]},
{name: 'setStart', signatures: [['node', 'offset']]},
{name: 'setEnd', signatures: [['node', 'offset']]},
{name: 'setStartBefore', signatures: [['node']]},
{name: 'setStartAfter', signatures: [['node']]},
{name: 'setEndBefore', signatures: [['node']]},
{name: 'setEndAfter', signatures: [['node']]},
{name: 'collapse', signatures: [['?toStart']], receiver: 'Range'},
{
name: 'collapse',
signatures: [['node', '?offset']],
receiver: 'Selection',
},
{name: 'selectNode', signatures: [['node']]},
{name: 'selectNodeContents', signatures: [['node']]},
{name: 'compareBoundaryPoints', signatures: [['how', 'sourceRange']]},
{name: 'insertNode', signatures: [['node']]},
{name: 'surroundContents', signatures: [['newParent']]},
{name: 'isPointInRange', signatures: [['node', 'offset']]},
{name: 'comparePoint', signatures: [['node', 'offset']]},
{name: 'intersectsNode', signatures: [['node']]},
{name: 'splitText', signatures: [['offset']]},
{
name: 'focus',
signatures: [['?options']],
receiver: 'HTMLOrForeignElement',
},
{name: 'updateSelection', signatures: [['start', 'end']]},
{name: 'updateLayout', signatures: [['controlBounds', 'selectionBounds']]},
{name: 'updateText', signatures: [['start', 'end', 'newText']]},
{name: 'getRangeAt', signatures: [['index']]},
{name: 'addRange', signatures: [['range']]},
{name: 'removeRange', signatures: [['range']]},
{
name: 'setPosition',
signatures: [['node', '?offset']],
receiver: 'Selection',
},
{
name: 'setPosition',
signatures: [['x', 'y', 'z']],
receiver: 'AudioListener',
},
{
name: 'setPosition',
signatures: [['x', 'y', 'z']],
receiver: 'PannerNode',
},
{name: 'extend', signatures: [['node', '?offset']]},
{
name: 'setBaseAndExtent',
signatures: [['baseNode', 'baseOffset', 'extentNode', 'extentOffset']],
},
{name: 'selectAllChildren', signatures: [['node']]},
{name: 'containsNode', signatures: [['node', '?allowPartialContainment']]},
{
name: 'initCompositionEvent',
signatures: [['?type', '?bubbles', '?cancelable', '?view', '?data']],
},
{name: 'getModifierState', signatures: [['keyArg']]},
{
name: 'initKeyboardEvent',
signatures: [
[
'type',
'?bubbles',
'?cancelable',
'?view',
'?keyIdentifier',
'?location',
'?ctrlKey',
'?altKey',
'?shiftKey',
'?metaKey',
],
],
},
{
name: 'initMessageEvent',
signatures: [
[
'type',
'?bubbles',
'?cancelable',
'?data',
'?origin',
'?lastEventId',
'?source',
'?ports',
],
],
},
{
name: 'initMouseEvent',
signatures: [
[
'?type',
'?bubbles',
'?cancelable',
'?view',
'?detail',
'?screenX',
'?screenY',
'?clientX',
'?clientY',
'?ctrlKey',
'?altKey',
'?shiftKey',
'?metaKey',
'?button',
'?relatedTarget',
],
],
},
{
name: 'initMutationEvent',
signatures: [
[
'?type',
'?bubbles',
'?cancelable',
'?relatedNode',
'?prevValue',
'?newValue',
'?attrName',
'?attrChange',
],
],
},
{
name: 'initTextEvent',
signatures: [['?type', '?bubbles', '?cancelable', '?view', '?data']],
},
{
name: 'initUIEvent',
signatures: [['?type', '?bubbles', '?cancelable', '?view', '?detail']],
},
{name: 'allowsFeature', signatures: [['feature', '?origin']]},
{name: 'getAllowlistForFeature', signatures: [['feature']]},
{name: 'redirect', signatures: [['url', '?status']]},
{name: 'fetch', signatures: [['input', '?init']], receiver: 'Window'},
{
name: 'fetch',
signatures: [['input', '?init']],
receiver: 'WorkerGlobalScope',
},
{
name: 'fetch',
signatures: [['id', 'requests', '?options']],
receiver: 'BackgroundFetchManager',
},
{name: 'readAsArrayBuffer', signatures: [['blob']]},
{name: 'readAsBinaryString', signatures: [['blob']]},
{name: 'readAsText', signatures: [['blob', '?label']]},
{name: 'readAsDataURL', signatures: [['blob']]},
{name: 'createObjectURL', signatures: [['blob'], ['source']]},
{name: 'revokeObjectURL', signatures: [['url']]},
{name: 'go', signatures: [['?delta']]},
{name: 'pushState', signatures: [['data', 'title', '?url']]},
{name: 'replaceState', signatures: [['data', 'title', '?url']]},
{name: 'isInputPending', signatures: [['?inputTypes']]},
{name: 'btoa', signatures: [['btoa']]},
{name: 'atob', signatures: [['atob']]},
{
name: 'createImageBitmap',
signatures: [
['imageBitmap', '?options'],
['imageBitmap', 'sx', 'sy', 'sw', 'sh', '?options'],
],
},
{
name: 'stop',
signatures: [['?when']],
receiver: 'AudioScheduledSourceNode',
},
{name: 'alert', signatures: [['?message']]},
{name: 'confirm', signatures: [['?message']]},
{
name: 'prompt',
signatures: [['?message', '?defaultValue']],
receiver: 'Window',
},
{
name: 'postMessage',
signatures: [
['message', '?options'],
['message', 'targetOrigin', '?transfer'],
],
receiver: 'Window',
},
{
name: 'postMessage',
signatures: [
['message', '?options'],
['message', 'targetOrigin', '?transfer'],
],
receiver: 'HTMLPortalElement',
},
{
name: 'postMessage',
signatures: [
['message', '?options'],
['message', 'targetOrigin', '?transfer'],
],
receiver: 'PortalHost',
},
{
name: 'postMessage',
signatures: [
['message', 'transfer'],
['message', '?options'],
],
receiver: 'MessagePort',
},
{
name: 'postMessage',
signatures: [
['message', 'transfer'],
['message', '?options'],
],
receiver: 'DedicatedWorkerGlobalScope',
},
{
name: 'postMessage',
signatures: [
['message', 'transfer'],
['message', '?options'],
],
receiver: 'Worker',
},
{
name: 'postMessage',
signatures: [['message']],
receiver: 'BroadcastChannel',
},
{
name: 'postMessage',
signatures: [
['message', 'transfer'],
['message', '?options'],
],
receiver: 'Client',
},
{
name: 'postMessage',
signatures: [
['message', 'transfer'],
['message', '?options'],
],
receiver: 'ServiceWorker',
},
{name: 'requestAnimationFrame', signatures: [['callback']]},
{name: 'cancelAnimationFrame', signatures: [['handle']]},
{name: 'requestPostAnimationFrame', signatures: [['callback']]},
{name: 'cancelPostAnimationFrame', signatures: [['handle']]},
{name: 'requestIdleCallback', signatures: [['callback', '?options']]},
{name: 'cancelIdleCallback', signatures: [['handle']]},
{name: 'getComputedStyle', signatures: [['elt', '?pseudoElt']]},
{name: 'matchMedia', signatures: [['query']]},
{name: 'moveTo', signatures: [['x', 'y']], receiver: 'Window'},
{name: 'moveTo', signatures: [['x', 'y']], receiver: 'CanvasPath'},
{name: 'moveTo', signatures: [['parent', 'name']], receiver: 'EntrySync'},
{
name: 'moveTo',
signatures: [['parent', '?name', '?successCallback', '?errorCallback']],
receiver: 'Entry',
},
{name: 'moveBy', signatures: [['x', 'y']]},
{name: 'resizeTo', signatures: [['x', 'y']]},
{name: 'resizeBy', signatures: [['x', 'y']]},
{name: 'getComputedAccessibleNode', signatures: [['element']]},
{name: 'webkitRequestAnimationFrame', signatures: [['callback']]},
{name: 'webkitCancelAnimationFrame', signatures: [['id']]},
{name: 'requestFullscreen', signatures: [['?options']]},
{name: 'webkitRequestFullScreen', signatures: [['?options']]},
{name: 'webkitRequestFullscreen', signatures: [['?options']]},
{name: 'fromMatrix', signatures: [['?other']]},
{name: 'fromFloat32Array', signatures: [['array32']]},
{name: 'fromFloat64Array', signatures: [['array64']]},
{
name: 'translate',
signatures: [['?tx', '?ty', '?tz']],
receiver: 'DOMMatrixReadOnly',
},
{name: 'translate', signatures: [['x', 'y']], receiver: 'SVGMatrix'},
{
name: 'translate',
signatures: [['x', 'y']],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'translate',
signatures: [['x', 'y']],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'translate',
signatures: [['x', 'y']],
receiver: 'PaintRenderingContext2D',
},
{
name: 'scale',
signatures: [
['?scaleX', '?scaleY', '?scaleZ', '?originX', '?originY', '?originZ'],
],
receiver: 'DOMMatrixReadOnly',
},
{name: 'scale', signatures: [['scaleFactor']], receiver: 'SVGMatrix'},
{
name: 'scale',
signatures: [['x', 'y']],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'scale',
signatures: [['x', 'y']],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'scale',
signatures: [['x', 'y']],
receiver: 'PaintRenderingContext2D',
},
{
name: 'scaleNonUniform',
signatures: [['?scaleX', '?scaleY']],
receiver: 'DOMMatrixReadOnly',
},
{
name: 'scaleNonUniform',
signatures: [['scaleFactorX', 'scaleFactorY']],
receiver: 'SVGMatrix',
},
{
name: 'scale3d',
signatures: [['?scale', '?originX', '?originY', '?originZ']],
},
{
name: 'rotate',
signatures: [['?rotX', '?rotY', '?rotZ']],
receiver: 'DOMMatrixReadOnly',
},
{name: 'rotate', signatures: [['angle']], receiver: 'SVGMatrix'},
{
name: 'rotate',
signatures: [['angle']],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'rotate',
signatures: [['angle']],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'rotate',
signatures: [['angle']],
receiver: 'PaintRenderingContext2D',
},
{
name: 'rotateFromVector',
signatures: [['?x', '?y']],
receiver: 'DOMMatrixReadOnly',
},
{name: 'rotateFromVector', signatures: [['x', 'y']], receiver: 'SVGMatrix'},
{name: 'rotateAxisAngle', signatures: [['?x', '?y', '?z', '?angle']]},
{name: 'skewX', signatures: [['?sx']], receiver: 'DOMMatrixReadOnly'},
{name: 'skewX', signatures: [['angle']], receiver: 'SVGMatrix'},
{name: 'skewY', signatures: [['?sy']], receiver: 'DOMMatrixReadOnly'},
{name: 'skewY', signatures: [['angle']], receiver: 'SVGMatrix'},
{name: 'multiply', signatures: [['?other']], receiver: 'DOMMatrixReadOnly'},
{name: 'multiply', signatures: [['secondMatrix']], receiver: 'SVGMatrix'},
{name: 'transformPoint', signatures: [['?point']]},
{name: 'multiplySelf', signatures: [['?other']]},
{name: 'preMultiplySelf', signatures: [['?other']]},
{name: 'translateSelf', signatures: [['?tx', '?ty', '?tz']]},
{
name: 'scaleSelf',
signatures: [
['?scaleX', '?scaleY', '?scaleZ', '?originX', '?originY', '?originZ'],
],
},
{
name: 'scale3dSelf',
signatures: [['?scale', '?originX', '?originY', '?originZ']],
},
{name: 'rotateSelf', signatures: [['?rotX', '?rotY', '?rotZ']]},
{name: 'rotateFromVectorSelf', signatures: [['?x', '?y']]},
{name: 'rotateAxisAngleSelf', signatures: [['?x', '?y', '?z', '?angle']]},
{name: 'skewXSelf', signatures: [['?sx']]},
{name: 'skewYSelf', signatures: [['?sy']]},
{name: 'setMatrixValue', signatures: [['transformList']]},
{name: 'fromPoint', signatures: [['?other']]},
{
name: 'matrixTransform',
signatures: [['?matrix']],
receiver: 'DOMPointReadOnly',
},
{name: 'matrixTransform', signatures: [['matrix']], receiver: 'SVGPoint'},
{name: 'fromRect', signatures: [['?other']]},
{name: 'fromQuad', signatures: [['?other']]},
{name: 'toDataURL', signatures: [['?type', '?quality']]},
{name: 'toBlob', signatures: [['callback', '?type', '?quality']]},
{name: 'convertToBlob', signatures: [['?options']]},
{name: 'define', signatures: [['name', 'constructor', '?options']]},
{name: 'whenDefined', signatures: [['name']]},
{name: 'upgrade', signatures: [['root']]},
{name: 'setFormValue', signatures: [['value', '?state']]},
{name: 'setValidity', signatures: [['flags', '?message', '?anchor']]},
{name: 'setCustomValidity', signatures: [['error']]},
{
name: 'namedItem',
signatures: [['name']],
receiver: 'HTMLFormControlsCollection',
},
{name: 'namedItem', signatures: [['name']], receiver: 'HTMLSelectElement'},
{name: 'namedItem', signatures: [['name']], receiver: 'HTMLAllCollection'},
{name: 'namedItem', signatures: [['name']], receiver: 'HTMLCollection'},
{name: 'namedItem', signatures: [['?name']], receiver: 'RTCStatsResponse'},
{name: 'namedItem', signatures: [['name']], receiver: 'MimeTypeArray'},
{name: 'namedItem', signatures: [['name']], receiver: 'PluginArray'},
{name: 'namedItem', signatures: [['name']], receiver: 'Plugin'},
{name: 'requestSubmit', signatures: [['?submitter']]},
{name: 'stepUp', signatures: [['?n']]},
{name: 'stepDown', signatures: [['?n']]},
{
name: 'select',
signatures: [['properties', '?options']],
receiver: 'ContactsManager',
},
{
name: 'setRangeText',
signatures: [['replacement', '?start', '?end', '?selectionMode']],
},
{name: 'setSelectionRange', signatures: [['start', 'end', '?direction']]},
{
name: 'Option',
signatures: [['?data', '?value', '?defaultSelected', '?selected']],
},
{
name: 'show',
signatures: [['?detailsPromise']],
receiver: 'PaymentRequest',
},
{name: 'Image', signatures: [['?width', '?height']]},
{
name: 'decode',
signatures: [['?input', '?options']],
receiver: 'TextDecoder',
},
{name: 'start', signatures: [['index']], receiver: 'TimeRanges'},
{
name: 'start',
signatures: [['controller']],
receiver: 'UnderlyingSinkBase',
},
{name: 'start', signatures: [['stream']], receiver: 'UnderlyingSourceBase'},
{name: 'start', signatures: [['?timeslice']], receiver: 'MediaRecorder'},
{
name: 'start',
signatures: [['remoteParameters', '?role']],
receiver: 'RTCIceTransport',
},
{
name: 'start',
signatures: [['?when', '?grainOffset', '?grainDuration']],
receiver: 'AudioBufferSourceNode',
},
{
name: 'start',
signatures: [['?when']],
receiver: 'AudioScheduledSourceNode',
},
{name: 'assignedNodes', signatures: [['?options']]},
{name: 'assignedElements', signatures: [['?options']]},
{name: 'insertRow', signatures: [['?index']]},
{name: 'deleteRow', signatures: [['index']]},
{name: 'insertCell', signatures: [['?index']]},
{name: 'deleteCell', signatures: [['index']]},
{name: 'Audio', signatures: [['?src']]},
{name: 'activate', signatures: [['?options']]},
{name: 'end', signatures: [['index']], receiver: 'TimeRanges'},
{name: 'getTrackById', signatures: [['id']], receiver: 'AudioTrackList'},
{name: 'getTrackById', signatures: [['id']], receiver: 'TextTrackList'},
{name: 'getTrackById', signatures: [['id']], receiver: 'VideoTrackList'},
{name: 'getTrackById', signatures: [['trackId']], receiver: 'MediaStream'},
{name: 'getCueById', signatures: [['id']]},
{name: 'addCue', signatures: [['cue']]},
{name: 'removeCue', signatures: [['cue']]},
{name: 'copyText', signatures: [['text']]},
{
name: 'showContextMenuAtPoint',
signatures: [['x', 'y', 'items', '?document']],
},
{name: 'sendMessageToEmbedder', signatures: [['message']]},
{name: 'send', signatures: [['command']], receiver: 'InspectorOverlayHost'},
{name: 'send', signatures: [['?body']], receiver: 'XMLHttpRequest'},
{name: 'send', signatures: [['data']], receiver: 'RTCDataChannel'},
{
name: 'send',
signatures: [['message'], ['data']],
receiver: 'PresentationConnection',
},
{
name: 'send',
signatures: [['data', '?timestamp']],
receiver: 'MIDIOutput',
},
{name: 'send', signatures: [['data']], receiver: 'WebSocket'},
{
name: 'unobserve',
signatures: [['target']],
receiver: 'IntersectionObserver',
},
{name: 'unobserve', signatures: [['target']], receiver: 'ResizeObserver'},
{name: 'unobserve', signatures: [['db']], receiver: 'IDBObserver'},
{name: 'layoutNextFragment', signatures: [['?options']]},
{name: 'registerLayout', signatures: [['name', 'layoutCtor']]},
{name: 'update', signatures: [['response']], receiver: 'MediaKeySession'},
{name: 'watch', signatures: [['signals', 'callback']]},
{name: 'writeMessage', signatures: [['buffer', 'handles']]},
{name: 'readMessage', signatures: [['?flags']]},
{name: 'writeData', signatures: [['buffer', '?options']]},
{name: 'discardData', signatures: [['numBytes', '?options']]},
{name: 'readData', signatures: [['buffer', '?options']]},
{name: 'mapBuffer', signatures: [['offset', 'numBytes']]},
{name: 'duplicateBufferHandle', signatures: [['?options']]},
{name: 'createDataPipe', signatures: [['options']]},
{name: 'createSharedBuffer', signatures: [['numBytes']]},
{
name: 'bindInterface',
signatures: [
[
'interfaceName',
'request_handle',
'?scope',
'?useBrowserInterfaceBroker',
],
],
},
{
name: 'setValueAndClosePopup',
signatures: [['numberValue', 'stringValue']],
},
{name: 'setValue', signatures: [['value']]},
{name: 'selectFontsFromOwnerDocument', signatures: [['targetDocument']]},
{name: 'localizeNumberString', signatures: [['numberString']]},
{name: 'formatMonth', signatures: [['year', 'zeroBaseMonth']]},
{name: 'formatShortMonth', signatures: [['year', 'zeroBaseMonth']]},
{
name: 'formatWeek',
signatures: [['year', 'weekNumber', 'localizedStartDate']],
},
{name: 'setWindowRect', signatures: [['x', 'y', 'width', 'height']]},
{name: 'consumeDelta', signatures: [['x', 'y']]},
{name: 'enqueue', signatures: [['?chunk']]},
{name: 'getReader', signatures: [['?mode']]},
{name: 'pipeThrough', signatures: [['transformStream', '?options']]},
{name: 'pipeTo', signatures: [['destination', '?option']]},
{
name: 'newValueSpecifiedUnits',
signatures: [['unitType', 'valueInSpecifiedUnits']],
},
{name: 'convertToSpecifiedUnits', signatures: [['unitType']]},
{name: 'beginElementAt', signatures: [['offset']]},
{name: 'endElementAt', signatures: [['offset']]},
{name: 'setStdDeviation', signatures: [['stdDeviationX', 'stdDeviationY']]},
{name: 'isPointInFill', signatures: [['point']]},
{
name: 'isPointInStroke',
signatures: [['point']],
receiver: 'SVGGeometryElement',
},
{
name: 'isPointInStroke',
signatures: [
['x', 'y'],
['path', 'x', 'y'],
],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'isPointInStroke',
signatures: [
['x', 'y'],
['path', 'x', 'y'],
],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'isPointInStroke',
signatures: [
['x', 'y'],
['path', 'x', 'y'],
],
receiver: 'PaintRenderingContext2D',
},
{name: 'getPointAtLength', signatures: [['distance']]},
{name: 'initialize', signatures: [['newItem']]},
{name: 'getItem', signatures: [['index']], receiver: 'SVGLengthList'},
{name: 'getItem', signatures: [['index']], receiver: 'SVGNumberList'},
{name: 'getItem', signatures: [['index']], receiver: 'SVGPointList'},
{name: 'getItem', signatures: [['index']], receiver: 'SVGStringList'},
{name: 'getItem', signatures: [['index']], receiver: 'SVGTransformList'},
{name: 'getItem', signatures: [['key']], receiver: 'Storage'},
{
name: 'insertItemBefore',
signatures: [['newItem', 'index']],
receiver: 'SVGLengthList',
},
{
name: 'insertItemBefore',
signatures: [['newItem', 'index']],
receiver: 'SVGNumberList',
},
{
name: 'insertItemBefore',
signatures: [['newItem', 'index']],
receiver: 'SVGPointList',
},
{
name: 'insertItemBefore',
signatures: [['item', 'index']],
receiver: 'SVGStringList',
},
{
name: 'insertItemBefore',
signatures: [['newItem', 'index']],
receiver: 'SVGTransformList',
},
{name: 'replaceItem', signatures: [['newItem', 'index']]},
{name: 'removeItem', signatures: [['index']], receiver: 'SVGLengthList'},
{name: 'removeItem', signatures: [['index']], receiver: 'SVGNumberList'},
{name: 'removeItem', signatures: [['index']], receiver: 'SVGPointList'},
{name: 'removeItem', signatures: [['index']], receiver: 'SVGStringList'},
{name: 'removeItem', signatures: [['index']], receiver: 'SVGTransformList'},
{name: 'removeItem', signatures: [['key']], receiver: 'Storage'},
{name: 'appendItem', signatures: [['newItem']]},
{name: 'setOrientToAngle', signatures: [['angle']]},
{name: 'getIntersectionList', signatures: [['rect', 'referenceElement']]},
{name: 'getEnclosureList', signatures: [['rect', 'referenceElement']]},
{name: 'checkIntersection', signatures: [['element', 'rect']]},
{name: 'checkEnclosure', signatures: [['element', 'rect']]},
{name: 'createSVGTransformFromMatrix', signatures: [['matrix']]},
{name: 'suspendRedraw', signatures: [['maxWaitMilliseconds']]},
{name: 'unsuspendRedraw', signatures: [['suspendHandleId']]},
{name: 'setCurrentTime', signatures: [['seconds']]},
{name: 'getSubStringLength', signatures: [['charnum', 'nchars']]},
{name: 'getStartPositionOfChar', signatures: [['charnum']]},
{name: 'getEndPositionOfChar', signatures: [['charnum']]},
{name: 'getExtentOfChar', signatures: [['charnum']]},
{name: 'getRotationOfChar', signatures: [['charnum']]},
{name: 'getCharNumAtPosition', signatures: [['point']]},
{name: 'selectSubString', signatures: [['charnum', 'nchars']]},
{name: 'setMatrix', signatures: [['matrix']]},
{name: 'setTranslate', signatures: [['tx', 'ty']]},
{name: 'setScale', signatures: [['sx', 'sy']]},
{name: 'setRotate', signatures: [['angle', 'cx', 'cy']]},
{name: 'setSkewX', signatures: [['angle']]},
{name: 'setSkewY', signatures: [['angle']]},
{name: 'getEntriesByType', signatures: [['entryType']]},
{name: 'getEntriesByName', signatures: [['name', '?entryType']]},
{name: 'setResourceTimingBufferSize', signatures: [['maxSize']]},
{name: 'mark', signatures: [['markName', '?markOptions']]},
{name: 'clearMarks', signatures: [['?markName']]},
{name: 'measure', signatures: [['measureName', '?startOrOptions', '?end']]},
{name: 'clearMeasures', signatures: [['?measureName']]},
{name: 'measureMemory', signatures: [['?options']]},
{name: 'createPolicy', signatures: [['policyName', 'policyOptions']]},
{name: 'isHTML', signatures: [['checkedObject']]},
{name: 'isScript', signatures: [['checkedObject']]},
{name: 'isScriptURL', signatures: [['checkedObject']]},
{
name: 'getPropertyType',
signatures: [['tagName', 'property', '?elementNS']],
},
{
name: 'getAttributeType',
signatures: [['tagName', 'attribute', '?elementNS', '?attrNs']],
},
{name: 'getTypeMapping', signatures: [['?ns']]},
{name: 'createHTML', signatures: [['input', '...args']]},
{name: 'createScript', signatures: [['input', '...args']]},
{name: 'createScriptURL', signatures: [['input', '...args']]},
{name: 'importScripts', signatures: [['...urls']]},
{name: 'addModule', signatures: [['moduleURL', '?options']]},
{name: 'createExpression', signatures: [['expression', '?resolver']]},
{name: 'createNSResolver', signatures: [['nodeResolver']]},
{
name: 'evaluate',
signatures: [
['expression', 'contextNode', '?resolver', '?type', '?inResult'],
],
receiver: 'Document',
},
{
name: 'evaluate',
signatures: [
['expression', 'contextNode', '?resolver', '?type', '?inResult'],
],
receiver: 'XPathEvaluator',
},
{
name: 'evaluate',
signatures: [['contextNode', '?type', '?inResult']],
receiver: 'XPathExpression',
},
{name: 'parseFromString', signatures: [['str', 'type']]},
{name: 'serializeToString', signatures: [['root']]},
{name: 'snapshotItem', signatures: [['index']]},
{name: 'importStylesheet', signatures: [['style']]},
{name: 'transformToFragment', signatures: [['source', 'output']]},
{name: 'transformToDocument', signatures: [['source']]},
{
name: 'setParameter',
signatures: [['namespaceURI', 'localName', 'value']],
},
{
name: 'getParameter',
signatures: [['namespaceURI', 'localName']],
receiver: 'XSLTProcessor',
},
{
name: 'getParameter',
signatures: [['pname']],
receiver: 'WebGLRenderingContextBase',
},
{name: 'removeParameter', signatures: [['namespaceURI', 'localName']]},
{name: 'setRequestHeader', signatures: [['name', 'value']]},
{name: 'getResponseHeader', signatures: [['name']]},
{name: 'overrideMimeType', signatures: [['mime']]},
{name: 'registerAnimator', signatures: [['name', 'animatorCtor']]},
{name: 'setSinkId', signatures: [['sinkId']]},
{
name: 'matchAll',
signatures: [['?request', '?options']],
receiver: 'BackgroundFetchRegistration',
},
{
name: 'matchAll',
signatures: [['?request', '?options']],
receiver: 'Cache',
},
{name: 'matchAll', signatures: [['?options']], receiver: 'Clients'},
{name: 'updateUI', signatures: [['?options']]},
{
name: 'register',
signatures: [['tag', '?options']],
receiver: 'PeriodicSyncManager',
},
{name: 'register', signatures: [['tag']], receiver: 'SyncManager'},
{
name: 'register',
signatures: [['url', '?options']],
receiver: 'ServiceWorkerContainer',
},
{
name: 'unregister',
signatures: [['tag']],
receiver: 'PeriodicSyncManager',
},
{name: 'setExperimentalAppBadge', signatures: [['?contents']]},
{name: 'sendBeacon', signatures: [['url', '?data']]},
{
name: 'getDescriptor',
signatures: [['descriptor']],
receiver: 'BluetoothRemoteGATTCharacteristic',
},
{
name: 'getDescriptor',
signatures: [['name']],
static: true,
receiver: 'BluetoothUUID',
},
{name: 'getDescriptors', signatures: [['?descriptor']]},
{name: 'writeValue', signatures: [['value']]},
{
name: 'connect',
signatures: [['destination', '?output', '?input']],
receiver: 'AudioNode',
},
{name: 'getPrimaryService', signatures: [['service']]},
{name: 'getPrimaryServices', signatures: [['?service']]},
{
name: 'getCharacteristic',
signatures: [['characteristic']],
receiver: 'BluetoothRemoteGATTService',
},
{
name: 'getCharacteristic',
signatures: [['name']],
static: true,
receiver: 'BluetoothUUID',
},
{name: 'getCharacteristics', signatures: [['?characteristic']]},
{name: 'getService', signatures: [['name']]},
{name: 'canonicalUUID', signatures: [['alias']]},
{name: 'requestDevice', signatures: [['?options']], receiver: 'Bluetooth'},
{name: 'requestDevice', signatures: [['options']], receiver: 'HID'},
{name: 'requestDevice', signatures: [['options']], receiver: 'USB'},
{name: 'requestLEScan', signatures: [['?options']]},
{name: 'addAll', signatures: [['requests']]},
{name: 'put', signatures: [['request', 'response']], receiver: 'Cache'},
{name: 'put', signatures: [['value', '?key']], receiver: 'IDBObjectStore'},
{name: 'addColorStop', signatures: [['offset', 'color']]},
{name: 'lineTo', signatures: [['x', 'y']]},
{name: 'quadraticCurveTo', signatures: [['cpx', 'cpy', 'x', 'y']]},
{
name: 'bezierCurveTo',
signatures: [['cp1x', 'cp1y', 'cp2x', 'cp2y', 'x', 'y']],
},
{name: 'arcTo', signatures: [['x1', 'y1', 'x2', 'y2', 'radius']]},
{name: 'rect', signatures: [['x', 'y', 'width', 'height']]},
{
name: 'arc',
signatures: [
['x', 'y', 'radius', 'startAngle', 'endAngle', '?anticlockwise'],
],
},
{
name: 'ellipse',
signatures: [
[
'x',
'y',
'radiusX',
'radiusY',
'rotation',
'startAngle',
'endAngle',
'?anticlockwise',
],
],
},
{
name: 'setTransform',
signatures: [['?transform']],
receiver: 'CanvasPattern',
},
{
name: 'setTransform',
signatures: [['?transform'], ['a', 'b', 'c', 'd', 'e', 'f']],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'setTransform',
signatures: [['?transform'], ['a', 'b', 'c', 'd', 'e', 'f']],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{
name: 'setTransform',
signatures: [['?transform'], ['a', 'b', 'c', 'd', 'e', 'f']],
receiver: 'PaintRenderingContext2D',
},
{name: 'transform', signatures: [['a', 'b', 'c', 'd', 'e', 'f']]},
{name: 'createLinearGradient', signatures: [['x0', 'y0', 'x1', 'y1']]},
{
name: 'createRadialGradient',
signatures: [['x0', 'y0', 'r0', 'x1', 'y1', 'r1']],
},
{name: 'createPattern', signatures: [['image', 'repetitionType']]},
{name: 'clearRect', signatures: [['x', 'y', 'width', 'height']]},
{name: 'fillRect', signatures: [['x', 'y', 'width', 'height']]},
{name: 'strokeRect', signatures: [['x', 'y', 'width', 'height']]},
{name: 'stroke', signatures: [['?path']]},
{name: 'drawFocusIfNeeded', signatures: [['element'], ['path', 'element']]},
{name: 'scrollPathIntoView', signatures: [['?path']]},
{name: 'clip', signatures: [['?winding'], ['path', '?winding']]},
{
name: 'isPointInPath',
signatures: [
['x', 'y', '?winding'],
['path', 'x', 'y', '?winding'],
],
},
{name: 'fillText', signatures: [['text', 'x', 'y', '?maxWidth']]},
{name: 'strokeText', signatures: [['text', 'x', 'y', '?maxWidth']]},
{name: 'measureText', signatures: [['text']]},
{
name: 'drawImage',
signatures: [
['image', 'x', 'y', '?width', '?height'],
['image', 'sx', 'sy', 'sw', 'sh', 'dx', 'dy', 'dw', 'dh'],
],
},
{name: 'addHitRegion', signatures: [['?options']]},
{name: 'removeHitRegion', signatures: [['id']]},
{
name: 'createImageData',
signatures: [
['imagedata'],
['sw', 'sh', '?imageDataColorSettings'],
['data', 'sw', 'sh', '?imageDataColorSettings'],
],
receiver: 'CanvasRenderingContext2D',
},
{
name: 'createImageData',
signatures: [
['imagedata'],
['sw', 'sh', '?imageDataColorSettings'],
['data', 'sw', 'sh', 'imageDataColorSettings'],
],
receiver: 'OffscreenCanvasRenderingContext2D',
},
{name: 'getImageData', signatures: [['sx', 'sy', 'sw', 'sh']]},
{
name: 'putImageData',
signatures: [
[
'imagedata',
'dx',
'dy',
'?dirtyX',
'?dirtyY',
'?dirtyWidth',
'?dirtyHeight',
],
],
},
{name: 'setLineDash', signatures: [['dash']]},
{name: 'addPath', signatures: [['path', '?transform']]},
{
name: 'getContext',
signatures: [['contextId', '?attributes']],
receiver: 'HTMLCanvasElement',
},
{
name: 'getContext',
signatures: [['contextType', '?attributes']],
receiver: 'OffscreenCanvas',
},
{name: 'transferFromImageBitmap', signatures: [['bitmap']]},
{name: 'writeText', signatures: [['data']]},
{name: 'subscribe', signatures: [['subscriptions']]},
{
name: 'unsubscribe',
signatures: [['subscriptions']],
receiver: 'CookieStoreManager',
},
{name: 'getRandomValues', signatures: [['array']]},
{name: 'encrypt', signatures: [['algorithm', 'key', 'data']]},
{name: 'decrypt', signatures: [['algorithm', 'key', 'data']]},
{name: 'verify', signatures: [['algorithm', 'key', 'signature', 'data']]},
{name: 'digest', signatures: [['algorithm', 'data']]},
{
name: 'generateKey',
signatures: [['algorithm', 'extractable', 'keyUsages']],
},
{
name: 'deriveKey',
signatures: [
['algorithm', 'baseKey', 'derivedKeyType', 'extractable', 'keyUsages'],
],
},
{name: 'deriveBits', signatures: [['algorithm', 'baseKey', 'length']]},
{
name: 'importKey',
signatures: [
['format', 'keyData', 'algorithm', 'extractable', 'keyUsages'],
],
},
{name: 'exportKey', signatures: [['format', 'key']]},
{
name: 'wrapKey',
signatures: [['format', 'key', 'wrappingKey', 'wrapAlgorithm']],
},
{
name: 'unwrapKey',
signatures: [
[
'format',
'wrappedKey',
'unwrappingKey',
'unwrapAlgorithm',
'unwrappedKeyAlgorithm',
'extractable',
'keyUsages',
],
],
},
{name: 'registerPaint', signatures: [['name', 'paintCtor']]},
{name: 'encode', signatures: [['?input']]},
{name: 'encodeInto', signatures: [['source', 'destination']]},
{name: 'setMediaKeys', signatures: [['mediaKeys']]},
{name: 'generateRequest', signatures: [['initDataType', 'initData']]},
{name: 'getStatusForPolicy', signatures: [['policy']]},
{name: 'createSession', signatures: [['?sessionType']]},
{name: 'setServerCertificate', signatures: [['serverCertificate']]},
{
name: 'requestMediaKeySystemAccess',
signatures: [['keySystem', 'supportedConfigurations']],
},
{
name: 'webkitRequestFileSystem',
signatures: [['type', 'size', '?successCallback', '?errorCallback']],
receiver: 'DedicatedWorkerGlobalScope',
},
{
name: 'webkitRequestFileSystem',
signatures: [['type', 'size', '?successCallback', '?errorCallback']],
receiver: 'SharedWorkerGlobalScope',
},
{
name: 'webkitRequestFileSystem',
signatures: [['type', 'size', 'successCallback', '?errorCallback']],
receiver: 'Window',
},
{name: 'webkitRequestFileSystemSync', signatures: [['type', 'size']]},
{
name: 'webkitResolveLocalFileSystemURL',
signatures: [['url', 'successCallback', '?errorCallback']],
},
{name: 'webkitResolveLocalFileSystemSyncURL', signatures: [['url']]},
{
name: 'isolatedFileSystem',
signatures: [['fileSystemId', 'registeredName']],
},
{
name: 'upgradeDraggedFileSystemPermissions',
signatures: [['domFileSystem']],
},
{
name: 'getFile',
signatures: [['path', 'flags']],
receiver: 'DirectoryEntrySync',
},
{
name: 'getFile',
signatures: [['path', '?options', '?successCallback', '?errorCallback']],
receiver: 'DirectoryEntry',
},
{
name: 'getFile',
signatures: [['name', '?options']],
receiver: 'FileSystemDirectoryHandle',
},
{
name: 'getDirectory',
signatures: [['path', 'flags']],
receiver: 'DirectoryEntrySync',
},
{
name: 'getDirectory',
signatures: [['path', '?options', '?successCallback', '?errorCallback']],
receiver: 'DirectoryEntry',
},
{
name: 'getDirectory',
signatures: [['name', '?options']],
receiver: 'FileSystemDirectoryHandle',
},
{
name: 'removeRecursively',
signatures: [['successCallback', '?errorCallback']],
receiver: 'DirectoryEntry',
},
{
name: 'readEntries',
signatures: [['successCallback', '?errorCallback']],
receiver: 'DirectoryReader',
},
{
name: 'getMetadata',
signatures: [['successCallback', '?errorCallback']],
receiver: 'Entry',
},
{name: 'copyTo', signatures: [['parent', 'name']], receiver: 'EntrySync'},
{
name: 'copyTo',
signatures: [['parent', '?name', '?successCallback', '?errorCallback']],
receiver: 'Entry',
},
{
name: 'getParent',
signatures: [['?successCallback', '?errorCallback']],
receiver: 'Entry',
},
{
name: 'file',
signatures: [['successCallback', '?errorCallback']],
receiver: 'FileEntry',
},
{
name: 'createWriter',
signatures: [['successCallback', '?errorCallback']],
receiver: 'FileEntry',
},
{
name: 'createWriter',
signatures: [['?options']],
receiver: 'FileSystemFileHandle',
},
{name: 'seek', signatures: [['position']], receiver: 'FileWriterSync'},
{name: 'seek', signatures: [['position']], receiver: 'FileWriter'},
{
name: 'seek',
signatures: [['offset']],
receiver: 'FileSystemWritableFileStream',
},
{name: 'truncate', signatures: [['size']]},
{name: 'playEffect', signatures: [['type', 'params']]},
{
name: 'getCurrentPosition',
signatures: [['successCallback', '?errorCallback', '?options']],
},
{
name: 'watchPosition',
signatures: [['successCallback', '?errorCallback', '?options']],
},
{name: 'clearWatch', signatures: [['watchID']]},
{name: 'sendReport', signatures: [['reportId', 'data']]},
{name: 'sendFeatureReport', signatures: [['reportId', 'data']]},
{name: 'receiveFeatureReport', signatures: [['reportId']]},
{name: 'takePhoto', signatures: [['?photoSettings']]},
{
name: 'transaction',
signatures: [['storeNames', '?mode', '?options']],
receiver: 'IDBDatabase',
},
{
name: 'transaction',
signatures: [['callback', '?errorCallback', '?successCallback']],
receiver: 'Database',
},
{name: 'createObjectStore', signatures: [['name', '?options']]},
{name: 'deleteObjectStore', signatures: [['name']]},
{name: 'deleteDatabase', signatures: [['name']]},
{name: 'cmp', signatures: [['first', 'second']]},
{name: 'getKey', signatures: [['key']], receiver: 'IDBIndex'},
{name: 'getKey', signatures: [['key']], receiver: 'IDBObjectStore'},
{name: 'getKey', signatures: [['name']], receiver: 'PushSubscription'},
{name: 'getAllKeys', signatures: [['?query', '?count']]},
{name: 'openCursor', signatures: [['?range', '?direction']]},
{name: 'openKeyCursor', signatures: [['?range', '?direction']]},
{name: 'only', signatures: [['value']]},
{name: 'lowerBound', signatures: [['bound', '?open']]},
{name: 'upperBound', signatures: [['bound', '?open']]},
{
name: 'bound',
signatures: [['lower', 'upper', '?lowerOpen', '?upperOpen']],
},
{name: 'index', signatures: [['name']]},
{name: 'createIndex', signatures: [['name', 'keyPath', '?options']]},
{name: 'deleteIndex', signatures: [['name']]},
{name: 'objectStore', signatures: [['name']]},
{name: 'lock', signatures: [['?keyCodes']], receiver: 'Keyboard'},
{
name: 'lock',
signatures: [['orientation']],
receiver: 'ScreenOrientation',
},
{name: 'setConsumer', signatures: [['consumer']]},
{
name: 'request',
signatures: [
['name', 'callback'],
['name', 'options', 'callback'],
],
receiver: 'LockManager',
},
{name: 'request', signatures: [['permissions']], receiver: 'Permissions'},
{name: 'request', signatures: [['type']], receiver: 'WakeLock'},
{name: 'query', signatures: [['permission']], receiver: 'Permissions'},
{name: 'decodingInfo', signatures: [['configuration']]},
{name: 'encodingInfo', signatures: [['configuration']]},
{
name: 'captureStream',
signatures: [['?frameRate']],
receiver: 'HTMLCanvasElement',
},
{name: 'isTypeSupported', signatures: [['type']]},
{name: 'setActionHandler', signatures: [['action', 'handler']]},
{name: 'setPositionState', signatures: [['state']]},
{name: 'addSourceBuffer', signatures: [['type']]},
{name: 'removeSourceBuffer', signatures: [['buffer']]},
{name: 'endOfStream', signatures: [['?error']]},
{name: 'setLiveSeekableRange', signatures: [['start', 'end']]},
{name: 'appendBuffer', signatures: [['data']]},
{name: 'changeType', signatures: [['type']]},
{
name: 'getCapabilities',
signatures: [['kind']],
static: true,
receiver: 'RTCRtpReceiver',
},
{
name: 'getCapabilities',
signatures: [['kind']],
static: true,
receiver: 'RTCRtpSender',
},
{
name: 'getUserMedia',
signatures: [['?constraints']],
receiver: 'MediaDevices',
},
{
name: 'getUserMedia',
signatures: [['constraints', 'successCallback', 'errorCallback']],
receiver: 'Navigator',
},
{name: 'getDisplayMedia', signatures: [['?constraints']]},
{name: 'applyConstraints', signatures: [['?constraints']]},
{name: 'addTrack', signatures: [['track']]},
{name: 'removeTrack', signatures: [['track']]},
{
name: 'webkitGetUserMedia',
signatures: [['constraints', 'successCallback', 'errorCallback']],
},
{name: 'removeEntry', signatures: [['name', '?options']]},
{name: 'getSystemDirectory', signatures: [['options']]},
{name: 'createWritable', signatures: [['?options']]},
{name: 'queryPermission', signatures: [['?descriptor']]},
{
name: 'requestPermission',
signatures: [['?descriptor']],
receiver: 'FileSystemHandle',
},
{
name: 'requestPermission',
signatures: [['?deprecatedCallback']],
static: true,
receiver: 'Notification',
},
{name: 'chooseFileSystemEntries', signatures: [['?options']]},
{name: 'registerProtocolHandler', signatures: [['scheme', 'url', 'title']]},
{name: 'unregisterProtocolHandler', signatures: [['scheme', 'url']]},
{name: 'showNotification', signatures: [['title', '?options']]},
{name: 'getNotifications', signatures: [['?filter']]},
{
name: 'respondWith',
signatures: [['paymentAbortedResponse']],
receiver: 'AbortPaymentEvent',
},
{
name: 'respondWith',
signatures: [['canMakePaymentResponse']],
receiver: 'CanMakePaymentEvent',
},
{
name: 'respondWith',
signatures: [['response']],
receiver: 'PaymentRequestEvent',
},
{name: 'respondWith', signatures: [['r']], receiver: 'FetchEvent'},
{
name: 'complete',
signatures: [['merchantSessionPromise']],
receiver: 'MerchantValidationEvent',
},
{
name: 'complete',
signatures: [['?paymentResult']],
receiver: 'PaymentResponse',
},
{name: 'enableDelegations', signatures: [['delegations']]},
{name: 'openWindow', signatures: [['url']]},
{
name: 'changePaymentMethod',
signatures: [['methodName', '?methodDetails']],
},
{name: 'changeShippingAddress', signatures: [['shippingAddress']]},
{name: 'changeShippingOption', signatures: [['shippingOption']]},
{name: 'updateWith', signatures: [['detailsPromise']]},
{name: 'retry', signatures: [['?errorFields']]},
{name: 'insertDTMF', signatures: [['tones', '?duration', '?interToneGap']]},
{name: 'gather', signatures: [['options']]},
{name: 'addRemoteCandidate', signatures: [['remoteCandidate']]},
{name: 'stat', signatures: [['name']]},
{name: 'readInto', signatures: [['data']]},
{name: 'waitForWriteBufferedAmountBelow', signatures: [['amount']]},
{name: 'waitForReadable', signatures: [['amount']]},
{name: 'listen', signatures: [['remote_key']]},
{name: 'sendDatagram', signatures: [['data']]},
{name: 'setParameters', signatures: [['?parameters']]},
{name: 'replaceTrack', signatures: [['withTrack']]},
{name: 'setStreams', signatures: [['...streams']]},
{name: 'setCodecPreferences', signatures: [['codecs']]},
{name: 'revoke', signatures: [['permission']]},
{name: 'requestAll', signatures: [['permissions']]},
{
name: 'requestPictureInPicture',
signatures: [['?options']],
receiver: 'HTMLElement',
},
{name: 'refresh', signatures: [['?reload']]},
{name: 'reconnect', signatures: [['id']]},
{
name: 'queryUsageAndQuota',
signatures: [['storageType', '?usageCallback', '?errorCallback']],
receiver: 'DeprecatedStorageInfo',
},
{
name: 'queryUsageAndQuota',
signatures: [['usageCallback', '?errorCallback']],
receiver: 'DeprecatedStorageQuota',
},
{
name: 'requestQuota',
signatures: [
['storageType', 'newQuotaInBytes', '?quotaCallback', '?errorCallback'],
],
receiver: 'DeprecatedStorageInfo',
},
{
name: 'requestQuota',
signatures: [['newQuotaInBytes', '?quotaCallback', '?errorCallback']],
receiver: 'DeprecatedStorageQuota',
},
{name: 'watchAvailability', signatures: [['callback']]},
{name: 'cancelWatchAvailability', signatures: [['?id']]},
{name: 'postTask', signatures: [['callback', '?options', '...arguments']]},
{name: 'setPriority', signatures: [['priority']]},
{name: 'populateMatrix', signatures: [['targetBuffer']]},
{name: 'requestPort', signatures: [['?options']]},
{name: 'waitUntil', signatures: [['f']]},
{name: 'addPerformanceEntry', signatures: [['entry']]},
{
name: 'enable',
signatures: [['cap']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'disable',
signatures: [['cap']],
receiver: 'WebGLRenderingContextBase',
},
{name: 'setHeaderValue', signatures: [['value']]},
{name: 'getRegistration', signatures: [['?documentURL']]},
{name: 'navigate', signatures: [['url']]},
{name: 'detect', signatures: [['image']]},
{name: 'receive', signatures: [['?options']]},
{name: 'addFromUri', signatures: [['src', '?weight']]},
{name: 'addFromString', signatures: [['string', '?weight']]},
{name: 'speak', signatures: [['utterance']]},
{
name: 'initStorageEvent',
signatures: [
[
'type',
'?bubbles',
'?cancelable',
'?key',
'?oldValue',
'?newValue',
'?url',
'?storageArea',
],
],
},
{name: 'key', signatures: [['index']]},
{name: 'setItem', signatures: [['key', 'value']]},
{name: 'vibrate', signatures: [['pattern']]},
{name: 'getFloatFrequencyData', signatures: [['array']]},
{name: 'getByteFrequencyData', signatures: [['array']]},
{name: 'getFloatTimeDomainData', signatures: [['array']]},
{name: 'getByteTimeDomainData', signatures: [['array']]},
{name: 'getChannelData', signatures: [['channelIndex']]},
{
name: 'copyFromChannel',
signatures: [['destination', 'channelNumber', '?bufferOffset']],
},
{
name: 'copyToChannel',
signatures: [['source', 'channelNumber', '?bufferOffset']],
},
{
name: 'suspend',
signatures: [['suspendTime']],
receiver: 'OfflineAudioContext',
},
{name: 'createMediaElementSource', signatures: [['mediaElement']]},
{name: 'createMediaStreamSource', signatures: [['mediaStream']]},
{
name: 'setOrientation',
signatures: [['x', 'y', 'z', 'xUp', 'yUp', 'zUp']],
receiver: 'AudioListener',
},
{
name: 'setOrientation',
signatures: [['x', 'y', 'z']],
receiver: 'PannerNode',
},
{name: 'setValueAtTime', signatures: [['value', 'time']]},
{name: 'linearRampToValueAtTime', signatures: [['value', 'time']]},
{name: 'exponentialRampToValueAtTime', signatures: [['value', 'time']]},
{name: 'setTargetAtTime', signatures: [['target', 'time', 'timeConstant']]},
{name: 'setValueCurveAtTime', signatures: [['values', 'time', 'duration']]},
{name: 'cancelScheduledValues', signatures: [['startTime']]},
{name: 'cancelAndHoldAtTime', signatures: [['startTime']]},
{name: 'registerProcessor', signatures: [['name', 'processorCtor']]},
{
name: 'createBuffer',
signatures: [['numberOfChannels', 'numberOfFrames', 'sampleRate']],
receiver: 'BaseAudioContext',
},
{
name: 'decodeAudioData',
signatures: [['audioData', '?successCallback', '?errorCallback']],
},
{name: 'createDelay', signatures: [['?maxDelayTime']]},
{name: 'createIIRFilter', signatures: [['feedForward', 'feedBack']]},
{
name: 'createScriptProcessor',
signatures: [
['?bufferSize', '?numberOfInputChannels', '?numberOfOutputChannels'],
],
},
{name: 'createPeriodicWave', signatures: [['real', 'imag', '?options']]},
{name: 'createChannelSplitter', signatures: [['?numberOfOutputs']]},
{name: 'createChannelMerger', signatures: [['?numberOfInputs']]},
{
name: 'getFrequencyResponse',
signatures: [['frequencyHz', 'magResponse', 'phaseResponse']],
},
{name: 'setPeriodicWave', signatures: [['periodicWave']]},
{name: 'Initialize', signatures: [['params']]},
{
name: 'changeVersion',
signatures: [
[
'oldVersion',
'newVersion',
'?callback',
'?errorCallback',
'?successCallback',
],
],
},
{
name: 'readTransaction',
signatures: [['callback', '?errorCallback', '?successCallback']],
},
{
name: 'executeSql',
signatures: [['sqlStatement', '?arguments', '?callback', '?errorCallback']],
},
{
name: 'openDatabase',
signatures: [
['name', 'version', 'displayName', 'estimatedSize', '?creationCallback'],
],
},
{
name: 'drawArraysInstancedANGLE',
signatures: [['mode', 'first', 'count', 'primcount']],
},
{
name: 'drawElementsInstancedANGLE',
signatures: [['mode', 'count', 'type', 'offset', 'primcount']],
},
{name: 'vertexAttribDivisorANGLE', signatures: [['index', 'divisor']]},
{name: 'queryCounterEXT', signatures: [['query', 'target']]},
{name: 'deleteQueryEXT', signatures: [['query']]},
{name: 'isQueryEXT', signatures: [['query']]},
{name: 'beginQueryEXT', signatures: [['target', 'query']]},
{name: 'endQueryEXT', signatures: [['target']]},
{name: 'getQueryEXT', signatures: [['target', 'pname']]},
{name: 'getQueryObjectEXT', signatures: [['query', 'pname']]},
{name: 'deleteVertexArrayOES', signatures: [['?arrayObject']]},
{name: 'isVertexArrayOES', signatures: [['?arrayObject']]},
{name: 'bindVertexArrayOES', signatures: [['?arrayObject']]},
{
name: 'framebufferTextureMultiviewOVR',
signatures: [
['target', 'attachment', 'texture', 'level', 'baseViewIndex', 'numViews'],
],
},
{name: 'getTranslatedShaderSource', signatures: [['shader']]},
{name: 'drawBuffersWEBGL', signatures: [['buffers']]},
{
name: 'drawArraysInstancedBaseInstanceWEBGL',
signatures: [['mode', 'first', 'count', 'instance_count', 'baseinstance']],
},
{
name: 'drawElementsInstancedBaseVertexBaseInstanceWEBGL',
signatures: [
[
'mode',
'count',
'type',
'offset',
'instance_count',
'basevertex',
'baseinstance',
],
],
},
{
name: 'multiDrawArraysInstancedBaseInstanceWEBGL',
signatures: [
[
'mode',
'firstsList',
'firstsOffset',
'countsList',
'countsOffset',
'instanceCountsList',
'instanceCountsOffset',
'baseInstancesList',
'baseInstancesOffset',
'drawcount',
],
],
},
{
name: 'multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL',
signatures: [
[
'mode',
'countsList',
'countsOffset',
'type',
'offsetsList',
'offsetsOffset',
'instanceCountsList',
'instanceCountsOffset',
'baseVerticesList',
'baseVerticesOffset',
'baseInstancesList',
'baseInstancesOffset',
'drawcount',
],
],
},
{
name: 'multiDrawArraysWEBGL',
signatures: [
[
'mode',
'firstsList',
'firstsOffset',
'countsList',
'countsOffset',
'drawcount',
],
],
},
{
name: 'multiDrawElementsWEBGL',
signatures: [
[
'mode',
'countsList',
'countsOffset',
'type',
'offsetsList',
'offsetsOffset',
'drawcount',
],
],
},
{
name: 'multiDrawArraysInstancedWEBGL',
signatures: [
[
'mode',
'firstsList',
'firstsOffset',
'countsList',
'countsOffset',
'instanceCountsList',
'instanceCountsOffset',
'drawcount',
],
],
},
{
name: 'multiDrawElementsInstancedWEBGL',
signatures: [
[
'mode',
'countsList',
'countsOffset',
'type',
'offsetsList',
'offsetsOffset',
'instanceCountsList',
'instanceCountsOffset',
'drawcount',
],
],
},
{name: 'activeTexture', signatures: [['texture']]},
{name: 'attachShader', signatures: [['program', 'shader']]},
{name: 'bindAttribLocation', signatures: [['program', 'index', 'name']]},
{name: 'bindBuffer', signatures: [['target', 'buffer']]},
{name: 'bindFramebuffer', signatures: [['target', 'framebuffer']]},
{name: 'bindRenderbuffer', signatures: [['target', 'renderbuffer']]},
{name: 'bindTexture', signatures: [['target', 'texture']]},
{name: 'blendColor', signatures: [['red', 'green', 'blue', 'alpha']]},
{name: 'blendEquation', signatures: [['mode']]},
{name: 'blendEquationSeparate', signatures: [['modeRGB', 'modeAlpha']]},
{name: 'blendFunc', signatures: [['sfactor', 'dfactor']]},
{
name: 'blendFuncSeparate',
signatures: [['srcRGB', 'dstRGB', 'srcAlpha', 'dstAlpha']],
},
{
name: 'bufferData',
signatures: [
['target', 'size', 'usage'],
['target', 'data', 'usage'],
],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'bufferData',
signatures: [['target', 'srcData', 'usage', 'srcOffset', '?length']],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'bufferSubData',
signatures: [['target', 'offset', 'data']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'bufferSubData',
signatures: [
['target', 'dstByteOffset', 'srcData', 'srcOffset', '?length'],
],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'checkFramebufferStatus', signatures: [['target']]},
{name: 'clearColor', signatures: [['red', 'green', 'blue', 'alpha']]},
{name: 'clearDepth', signatures: [['depth']]},
{name: 'clearStencil', signatures: [['s']]},
{name: 'colorMask', signatures: [['red', 'green', 'blue', 'alpha']]},
{name: 'compileShader', signatures: [['shader']]},
{
name: 'compressedTexImage2D',
signatures: [
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'data',
],
],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'compressedTexImage2D',
signatures: [
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'imageSize',
'offset',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'data',
'srcOffset',
'?srcLengthOverride',
],
],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'compressedTexSubImage2D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'data',
],
],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'compressedTexSubImage2D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'imageSize',
'offset',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'data',
'srcOffset',
'?srcLengthOverride',
],
],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'copyTexImage2D',
signatures: [
[
'target',
'level',
'internalformat',
'x',
'y',
'width',
'height',
'border',
],
],
},
{
name: 'copyTexSubImage2D',
signatures: [
['target', 'level', 'xoffset', 'yoffset', 'x', 'y', 'width', 'height'],
],
},
{name: 'createShader', signatures: [['type']]},
{name: 'cullFace', signatures: [['mode']]},
{name: 'deleteBuffer', signatures: [['buffer']]},
{name: 'deleteFramebuffer', signatures: [['framebuffer']]},
{name: 'deleteProgram', signatures: [['program']]},
{name: 'deleteRenderbuffer', signatures: [['renderbuffer']]},
{name: 'deleteShader', signatures: [['shader']]},
{name: 'deleteTexture', signatures: [['texture']]},
{name: 'depthFunc', signatures: [['func']]},
{name: 'depthMask', signatures: [['flag']]},
{name: 'depthRange', signatures: [['zNear', 'zFar']]},
{name: 'detachShader', signatures: [['program', 'shader']]},
{name: 'disableVertexAttribArray', signatures: [['index']]},
{name: 'drawArrays', signatures: [['mode', 'first', 'count']]},
{name: 'drawElements', signatures: [['mode', 'count', 'type', 'offset']]},
{name: 'enableVertexAttribArray', signatures: [['index']]},
{
name: 'framebufferRenderbuffer',
signatures: [
['target', 'attachment', 'renderbuffertarget', 'renderbuffer'],
],
},
{
name: 'framebufferTexture2D',
signatures: [['target', 'attachment', 'textarget', 'texture', 'level']],
},
{name: 'frontFace', signatures: [['mode']]},
{name: 'generateMipmap', signatures: [['target']]},
{name: 'getActiveAttrib', signatures: [['program', 'index']]},
{name: 'getActiveUniform', signatures: [['program', 'index']]},
{name: 'getAttachedShaders', signatures: [['program']]},
{name: 'getAttribLocation', signatures: [['program', 'name']]},
{name: 'getBufferParameter', signatures: [['target', 'pname']]},
{name: 'getExtension', signatures: [['name']]},
{
name: 'getFramebufferAttachmentParameter',
signatures: [['target', 'attachment', 'pname']],
},
{name: 'getProgramParameter', signatures: [['program', 'pname']]},
{name: 'getProgramInfoLog', signatures: [['program']]},
{name: 'getRenderbufferParameter', signatures: [['target', 'pname']]},
{name: 'getShaderParameter', signatures: [['shader', 'pname']]},
{name: 'getShaderInfoLog', signatures: [['shader']]},
{
name: 'getShaderPrecisionFormat',
signatures: [['shadertype', 'precisiontype']],
},
{name: 'getShaderSource', signatures: [['shader']]},
{name: 'getTexParameter', signatures: [['target', 'pname']]},
{name: 'getUniform', signatures: [['program', 'location']]},
{name: 'getUniformLocation', signatures: [['program', 'name']]},
{name: 'getVertexAttrib', signatures: [['index', 'pname']]},
{name: 'getVertexAttribOffset', signatures: [['index', 'pname']]},
{name: 'hint', signatures: [['target', 'mode']]},
{name: 'isBuffer', signatures: [['buffer']]},
{name: 'isEnabled', signatures: [['cap']]},
{name: 'isFramebuffer', signatures: [['framebuffer']]},
{name: 'isProgram', signatures: [['program']]},
{name: 'isRenderbuffer', signatures: [['renderbuffer']]},
{name: 'isShader', signatures: [['shader']]},
{name: 'isTexture', signatures: [['texture']]},
{name: 'lineWidth', signatures: [['width']]},
{name: 'linkProgram', signatures: [['program']]},
{name: 'pixelStorei', signatures: [['pname', 'param']]},
{name: 'polygonOffset', signatures: [['factor', 'units']]},
{
name: 'readPixels',
signatures: [['x', 'y', 'width', 'height', 'format', 'type', 'pixels']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'readPixels',
signatures: [
['x', 'y', 'width', 'height', 'format', 'type', 'offset'],
['x', 'y', 'width', 'height', 'format', 'type', 'dstData', 'offset'],
],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'renderbufferStorage',
signatures: [['target', 'internalformat', 'width', 'height']],
},
{name: 'sampleCoverage', signatures: [['value', 'invert']]},
{name: 'scissor', signatures: [['x', 'y', 'width', 'height']]},
{name: 'shaderSource', signatures: [['shader', 'string']]},
{name: 'stencilFunc', signatures: [['func', 'ref', 'mask']]},
{
name: 'stencilFuncSeparate',
signatures: [['face', 'func', 'ref', 'mask']],
},
{name: 'stencilMask', signatures: [['mask']]},
{name: 'stencilMaskSeparate', signatures: [['face', 'mask']]},
{name: 'stencilOp', signatures: [['fail', 'zfail', 'zpass']]},
{
name: 'stencilOpSeparate',
signatures: [['face', 'fail', 'zfail', 'zpass']],
},
{name: 'texParameterf', signatures: [['target', 'pname', 'param']]},
{name: 'texParameteri', signatures: [['target', 'pname', 'param']]},
{
name: 'texImage2D',
signatures: [
['target', 'level', 'internalformat', 'format', 'type', 'pixels'],
['target', 'level', 'internalformat', 'format', 'type', 'image'],
['target', 'level', 'internalformat', 'format', 'type', 'canvas'],
[
'target',
'level',
'internalformat',
'format',
'type',
'offscreenCanvas',
],
['target', 'level', 'internalformat', 'format', 'type', 'video'],
['target', 'level', 'internalformat', 'format', 'type', 'bitmap'],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'pixels',
],
],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'texImage2D',
signatures: [
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'offset',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'data',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'image',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'canvas',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'offscreenCanvas',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'video',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'bitmap',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'border',
'format',
'type',
'srcData',
'srcOffset',
],
],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'texSubImage2D',
signatures: [
['target', 'level', 'xoffset', 'yoffset', 'format', 'type', 'pixels'],
['target', 'level', 'xoffset', 'yoffset', 'format', 'type', 'image'],
['target', 'level', 'xoffset', 'yoffset', 'format', 'type', 'canvas'],
[
'target',
'level',
'xoffset',
'yoffset',
'format',
'type',
'offscreenCanvas',
],
['target', 'level', 'xoffset', 'yoffset', 'format', 'type', 'video'],
['target', 'level', 'xoffset', 'yoffset', 'format', 'type', 'bitmap'],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'pixels',
],
],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'texSubImage2D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'offset',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'data',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'image',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'canvas',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'offscreenCanvas',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'video',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'bitmap',
],
[
'target',
'level',
'xoffset',
'yoffset',
'width',
'height',
'format',
'type',
'srcData',
'srcOffset',
],
],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform1f', signatures: [['location', 'x']]},
{
name: 'uniform1fv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform1fv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform1i', signatures: [['location', 'x']]},
{
name: 'uniform1iv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform1iv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform2f', signatures: [['location', 'x', 'y']]},
{
name: 'uniform2fv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform2fv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform2i', signatures: [['location', 'x', 'y']]},
{
name: 'uniform2iv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform2iv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform3f', signatures: [['location', 'x', 'y', 'z']]},
{
name: 'uniform3fv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform3fv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform3i', signatures: [['location', 'x', 'y', 'z']]},
{
name: 'uniform3iv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform3iv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform4f', signatures: [['location', 'x', 'y', 'z', 'w']]},
{
name: 'uniform4fv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform4fv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'uniform4i', signatures: [['location', 'x', 'y', 'z', 'w']]},
{
name: 'uniform4iv',
signatures: [['location', 'v']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniform4iv',
signatures: [['location', 'v', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'uniformMatrix2fv',
signatures: [['location', 'transpose', 'array']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniformMatrix2fv',
signatures: [['location', 'transpose', 'array', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'uniformMatrix3fv',
signatures: [['location', 'transpose', 'array']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniformMatrix3fv',
signatures: [['location', 'transpose', 'array', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{
name: 'uniformMatrix4fv',
signatures: [['location', 'transpose', 'array']],
receiver: 'WebGLRenderingContextBase',
},
{
name: 'uniformMatrix4fv',
signatures: [['location', 'transpose', 'array', 'srcOffset', '?srcLength']],
receiver: 'WebGL2RenderingContextBase',
},
{name: 'useProgram', signatures: [['program']]},
{name: 'validateProgram', signatures: [['program']]},
{name: 'vertexAttrib1f', signatures: [['indx', 'x']]},
{name: 'vertexAttrib1fv', signatures: [['indx', 'values']]},
{name: 'vertexAttrib2f', signatures: [['indx', 'x', 'y']]},
{name: 'vertexAttrib2fv', signatures: [['indx', 'values']]},
{name: 'vertexAttrib3f', signatures: [['indx', 'x', 'y', 'z']]},
{name: 'vertexAttrib3fv', signatures: [['indx', 'values']]},
{name: 'vertexAttrib4f', signatures: [['indx', 'x', 'y', 'z', 'w']]},
{name: 'vertexAttrib4fv', signatures: [['indx', 'values']]},
{
name: 'vertexAttribPointer',
signatures: [['indx', 'size', 'type', 'normalized', 'stride', 'offset']],
},
{name: 'viewport', signatures: [['x', 'y', 'width', 'height']]},
{name: 'VideoElementTargetVideoTexture', signatures: [['target', 'video']]},
{
name: 'dispatchCompute',
signatures: [['numGroupsX', 'numGroupsY', 'numGroupsZ']],
},
{name: 'dispatchComputeIndirect', signatures: [['offset']]},
{name: 'drawArraysIndirect', signatures: [['mode', 'offset']]},
{name: 'drawElementsIndirect', signatures: [['mode', 'type', 'offset']]},
{
name: 'getProgramInterfaceParameter',
signatures: [['program', 'programInterface', 'pname']],
},
{
name: 'getProgramResourceIndex',
signatures: [['program', 'programInterface', 'name']],
},
{
name: 'getProgramResourceName',
signatures: [['program', 'programInterface', 'index']],
},
{
name: 'getProgramResource',
signatures: [['program', 'programInterface', 'index', 'props']],
},
{
name: 'getProgramResourceLocation',
signatures: [['program', 'programInterface', 'name']],
},
{
name: 'bindImageTexture',
signatures: [
['unit', 'texture', 'level', 'layered', 'layer', 'access', 'format'],
],
},
{name: 'memoryBarrier', signatures: [['barriers']]},
{name: 'memoryBarrierByRegion', signatures: [['barriers']]},
{
name: 'copyBufferSubData',
signatures: [
['readTarget', 'writeTarget', 'readOffset', 'writeOffset', 'size'],
],
},
{
name: 'getBufferSubData',
signatures: [
['target', 'srcByteOffset', 'dstData', '?dstOffset', '?length'],
],
},
{
name: 'blitFramebuffer',
signatures: [
[
'srcX0',
'srcY0',
'srcX1',
'srcY1',
'dstX0',
'dstY0',
'dstX1',
'dstY1',
'mask',
'filter',
],
],
},
{
name: 'framebufferTextureLayer',
signatures: [['target', 'attachment', 'texture', 'level', 'layer']],
},
{
name: 'getInternalformatParameter',
signatures: [['target', 'internalformat', 'pname']],
},
{name: 'invalidateFramebuffer', signatures: [['target', 'attachments']]},
{
name: 'invalidateSubFramebuffer',
signatures: [['target', 'attachments', 'x', 'y', 'width', 'height']],
},
{name: 'readBuffer', signatures: [['mode']]},
{
name: 'renderbufferStorageMultisample',
signatures: [['target', 'samples', 'internalformat', 'width', 'height']],
},
{
name: 'texStorage2D',
signatures: [['target', 'levels', 'internalformat', 'width', 'height']],
},
{
name: 'texStorage3D',
signatures: [
['target', 'levels', 'internalformat', 'width', 'height', 'depth'],
],
},
{
name: 'texImage3D',
signatures: [
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'offset',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'data',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'image',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'canvas',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'offscreenCanvas',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'video',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'bitmap',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'format',
'type',
'pixels',
'?srcOffset',
],
],
},
{
name: 'texSubImage3D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'offset',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'data',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'image',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'canvas',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'offscreenCanvas',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'video',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'bitmap',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'type',
'pixels',
'?srcOffset',
],
],
},
{
name: 'copyTexSubImage3D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'x',
'y',
'width',
'height',
],
],
},
{
name: 'compressedTexImage3D',
signatures: [
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'imageSize',
'offset',
],
[
'target',
'level',
'internalformat',
'width',
'height',
'depth',
'border',
'data',
'?srcOffset',
'?srcLengthOverride',
],
],
},
{
name: 'compressedTexSubImage3D',
signatures: [
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'imageSize',
'offset',
],
[
'target',
'level',
'xoffset',
'yoffset',
'zoffset',
'width',
'height',
'depth',
'format',
'data',
'?srcOffset',
'?srcLengthOverride',
],
],
},
{name: 'getFragDataLocation', signatures: [['program', 'name']]},
{name: 'uniform1ui', signatures: [['location', 'v0']]},
{name: 'uniform2ui', signatures: [['location', 'v0', 'v1']]},
{name: 'uniform3ui', signatures: [['location', 'v0', 'v1', 'v2']]},
{name: 'uniform4ui', signatures: [['location', 'v0', 'v1', 'v2', 'v3']]},
{
name: 'uniform1uiv',
signatures: [['location', 'v', '?srcOffset', '?srcLength']],
},
{
name: 'uniform2uiv',
signatures: [['location', 'v', '?srcOffset', '?srcLength']],
},
{
name: 'uniform3uiv',
signatures: [['location', 'v', '?srcOffset', '?srcLength']],
},
{
name: 'uniform4uiv',
signatures: [['location', 'v', '?srcOffset', '?srcLength']],
},
{
name: 'uniformMatrix2x3fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{
name: 'uniformMatrix3x2fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{
name: 'uniformMatrix2x4fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{
name: 'uniformMatrix4x2fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{
name: 'uniformMatrix3x4fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{
name: 'uniformMatrix4x3fv',
signatures: [
['location', 'transpose', 'value', '?srcOffset', '?srcLength'],
],
},
{name: 'vertexAttribI4i', signatures: [['index', 'x', 'y', 'z', 'w']]},
{name: 'vertexAttribI4iv', signatures: [['index', 'v']]},
{name: 'vertexAttribI4ui', signatures: [['index', 'x', 'y', 'z', 'w']]},
{name: 'vertexAttribI4uiv', signatures: [['index', 'v']]},
{
name: 'vertexAttribIPointer',
signatures: [['index', 'size', 'type', 'stride', 'offset']],
},
{name: 'vertexAttribDivisor', signatures: [['index', 'divisor']]},
{
name: 'drawArraysInstanced',
signatures: [['mode', 'first', 'count', 'instanceCount']],
},
{
name: 'drawElementsInstanced',
signatures: [['mode', 'count', 'type', 'offset', 'instanceCount']],
},
{
name: 'drawRangeElements',
signatures: [['mode', 'start', 'end', 'count', 'type', 'offset']],
},
{name: 'drawBuffers', signatures: [['buffers']]},
{
name: 'clearBufferiv',
signatures: [['buffer', 'drawbuffer', 'value', '?srcOffset']],
},
{
name: 'clearBufferuiv',
signatures: [['buffer', 'drawbuffer', 'value', '?srcOffset']],
},
{
name: 'clearBufferfv',
signatures: [['buffer', 'drawbuffer', 'value', '?srcOffset']],
},
{
name: 'clearBufferfi',
signatures: [['buffer', 'drawbuffer', 'depth', 'stencil']],
},
{name: 'deleteQuery', signatures: [['query']]},
{name: 'isQuery', signatures: [['query']]},
{name: 'beginQuery', signatures: [['target', 'query']]},
{name: 'endQuery', signatures: [['target']]},
{name: 'getQuery', signatures: [['target', 'pname']]},
{name: 'getQueryParameter', signatures: [['query', 'pname']]},
{name: 'deleteSampler', signatures: [['sampler']]},
{name: 'isSampler', signatures: [['sampler']]},
{name: 'bindSampler', signatures: [['unit', 'sampler']]},
{name: 'samplerParameteri', signatures: [['sampler', 'pname', 'param']]},
{name: 'samplerParameterf', signatures: [['sampler', 'pname', 'param']]},
{name: 'getSamplerParameter', signatures: [['sampler', 'pname']]},
{name: 'fenceSync', signatures: [['condition', 'flags']]},
{name: 'isSync', signatures: [['sync']]},
{name: 'deleteSync', signatures: [['sync']]},
{name: 'clientWaitSync', signatures: [['sync', 'flags', 'timeout']]},
{name: 'waitSync', signatures: [['sync', 'flags', 'timeout']]},
{name: 'getSyncParameter', signatures: [['sync', 'pname']]},
{name: 'deleteTransformFeedback', signatures: [['feedback']]},
{name: 'isTransformFeedback', signatures: [['feedback']]},
{name: 'bindTransformFeedback', signatures: [['target', 'feedback']]},
{name: 'beginTransformFeedback', signatures: [['primitiveMode']]},
{
name: 'transformFeedbackVaryings',
signatures: [['program', 'varyings', 'bufferMode']],
},
{name: 'getTransformFeedbackVarying', signatures: [['program', 'index']]},
{name: 'bindBufferBase', signatures: [['target', 'index', 'buffer']]},
{
name: 'bindBufferRange',
signatures: [['target', 'index', 'buffer', 'offset', 'size']],
},
{name: 'getIndexedParameter', signatures: [['target', 'index']]},
{name: 'getUniformIndices', signatures: [['program', 'uniformNames']]},
{
name: 'getActiveUniforms',
signatures: [['program', 'uniformIndices', 'pname']],
},
{
name: 'getUniformBlockIndex',
signatures: [['program', 'uniformBlockName']],
},
{
name: 'getActiveUniformBlockParameter',
signatures: [['program', 'uniformBlockIndex', 'pname']],
},
{
name: 'getActiveUniformBlockName',
signatures: [['program', 'uniformBlockIndex']],
},
{
name: 'uniformBlockBinding',
signatures: [['program', 'uniformBlockIndex', 'uniformBlockBinding']],
},
{name: 'deleteVertexArray', signatures: [['vertexArray']]},
{name: 'isVertexArray', signatures: [['vertexArray']]},
{name: 'bindVertexArray', signatures: [['vertexArray']]},
{
name: 'setSubData',
signatures: [['dstOffset', 'src', '?srcOffset', '?byteLength']],
},
{name: 'configureSwapChain', signatures: [['descriptor']]},
{name: 'getSwapChainPreferredFormat', signatures: [['device']]},
{name: 'setPipeline', signatures: [['pipeline']]},
{name: 'dispatch', signatures: [['x', '?y', '?z']]},
{
name: 'dispatchIndirect',
signatures: [['indirectBuffer', 'indirectOffset']],
},
{name: 'getBindGroupLayout', signatures: [['index']]},
{name: 'onCompletion', signatures: [['completionValue']]},
{
name: 'setBindGroup',
signatures: [
['index', 'bindGroup', '?dynamicOffsets'],
[
'index',
'bindGroup',
'dynamicOffsetsData',
'dynamicOffsetsDataStart',
'dynamicOffsetsDataLength',
],
],
},
{name: 'pushDebugGroup', signatures: [['groupLabel']]},
{name: 'insertDebugMarker', signatures: [['markerLabel']]},
{name: 'setIndexBuffer', signatures: [['buffer', '?offset']]},
{name: 'setVertexBuffer', signatures: [['slot', 'buffer', '?offset']]},
{
name: 'draw',
signatures: [
['vertexCount', 'instanceCount', 'firstVertex', 'firstInstance'],
],
},
{
name: 'drawIndexed',
signatures: [
[
'indexCount',
'instanceCount',
'firstIndex',
'baseVertex',
'firstInstance',
],
],
},
{name: 'drawIndirect', signatures: [['indirectBuffer', 'indirectOffset']]},
{
name: 'drawIndexedIndirect',
signatures: [['indirectBuffer', 'indirectOffset']],
},
{
name: 'setViewport',
signatures: [['x', 'y', 'width', 'height', 'minDepth', 'maxDepth']],
},
{name: 'setScissorRect', signatures: [['x', 'y', 'width', 'height']]},
{name: 'setBlendColor', signatures: [['color']]},
{name: 'setStencilReference', signatures: [['reference']]},
{name: 'executeBundles', signatures: [['bundles']]},
{name: 'requestMIDIAccess', signatures: [['?options']]},
{name: 'canShare', signatures: [['?data']]},
{name: 'share', signatures: [['?data']]},
{name: 'selectConfiguration', signatures: [['configurationValue']]},
{name: 'claimInterface', signatures: [['interfaceNumber']]},
{name: 'releaseInterface', signatures: [['interfaceNumber']]},
{
name: 'selectAlternateInterface',
signatures: [['interfaceNumber', 'alternateSetting']],
},
{name: 'controlTransferIn', signatures: [['setup', 'length']]},
{name: 'controlTransferOut', signatures: [['setup', '?data']]},
{name: 'clearHalt', signatures: [['direction', 'endpointNumber']]},
{name: 'transferIn', signatures: [['endpointNumber', 'length']]},
{name: 'transferOut', signatures: [['endpointNumber', 'data']]},
{
name: 'isochronousTransferIn',
signatures: [['endpointNumber', 'packetLengths']],
},
{
name: 'isochronousTransferOut',
signatures: [['endpointNumber', 'data', 'packetLengths']],
},
{name: 'getViewerPose', signatures: [['referenceSpace']]},
{
name: 'getPose',
signatures: [['space', 'relativeTo']],
receiver: 'XRFrame',
},
{
name: 'getPose',
signatures: [['relative_to']],
receiver: 'XRHitTestResult',
},
{name: 'getHitTestResults', signatures: [['hitTestSource']]},
{
name: 'getHitTestResultsForTransientInput',
signatures: [['hitTestSource']],
},
{name: 'createAnchor', signatures: [['initial_pose', 'space']]},
{name: 'getOffsetReferenceSpace', signatures: [['originOffset']]},
{name: 'updateRenderState', signatures: [['?init']]},
{name: 'requestReferenceSpace', signatures: [['type']]},
{name: 'requestHitTest', signatures: [['ray', 'space']]},
{name: 'updateWorldTrackingState', signatures: [['?state']]},
{name: 'requestHitTestSource', signatures: [['options']]},
{name: 'requestHitTestSourceForTransientInput', signatures: [['options']]},
{name: 'getViewport', signatures: [['view']]},
{name: 'getNativeFramebufferScaleFactor', signatures: [['session']]},
{name: 'supportsSession', signatures: [['mode']]},
{name: 'isSessionSupported', signatures: [['mode']]},
{name: 'requestSession', signatures: [['mode', '?options']]},
];
Reference in New Issue View Git Blame Copy Permalink