1/*
2 This file is part of the WebKit open source project.
3 This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this library; see the file COPYING.LIB. If not, write to
17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20
21#include "config.h"
22#include "JSInternals.h"
23
24#include "Document.h"
25#include "JSCSSStyleDeclaration.h"
26#include "JSDOMAttribute.h"
27#include "JSDOMBinding.h"
28#include "JSDOMConvertAny.h"
29#include "JSDOMConvertBoolean.h"
30#include "JSDOMConvertBufferSource.h"
31#include "JSDOMConvertCallbacks.h"
32#include "JSDOMConvertInterface.h"
33#include "JSDOMConvertNullable.h"
34#include "JSDOMConvertNumbers.h"
35#include "JSDOMConvertSequences.h"
36#include "JSDOMConvertSerializedScriptValue.h"
37#include "JSDOMConvertStrings.h"
38#include "JSDOMExceptionHandling.h"
39#include "JSDOMGlobalObject.h"
40#include "JSDOMOperation.h"
41#include "JSDOMOperationReturningPromise.h"
42#include "JSDOMRect.h"
43#include "JSDOMRectList.h"
44#include "JSDOMURL.h"
45#include "JSDOMWrapperCache.h"
46#include "JSDocument.h"
47#include "JSElement.h"
48#include "JSFetchResponse.h"
49#include "JSFile.h"
50#include "JSGCObservation.h"
51#include "JSHTMLImageElement.h"
52#include "JSHTMLInputElement.h"
53#include "JSHTMLLinkElement.h"
54#include "JSHTMLSelectElement.h"
55#include "JSInternalSettings.h"
56#include "JSMallocStatistics.h"
57#include "JSMemoryInfo.h"
58#include "JSMockPageOverlay.h"
59#include "JSNode.h"
60#include "JSNodeList.h"
61#include "JSRange.h"
62#include "JSSVGSVGElement.h"
63#include "JSStringCallback.h"
64#include "JSStyleSheet.h"
65#include "JSTypeConversions.h"
66#include "JSVoidCallback.h"
67#include "JSWindowProxy.h"
68#include "JSXMLHttpRequest.h"
69#include "ScriptExecutionContext.h"
70#include "SerializedScriptValue.h"
71#include <JavaScriptCore/HeapSnapshotBuilder.h>
72#include <JavaScriptCore/JSArray.h>
73#include <JavaScriptCore/JSCInlines.h>
74#include <JavaScriptCore/JSString.h>
75#include <JavaScriptCore/ObjectConstructor.h>
76#include <wtf/GetPtr.h>
77#include <wtf/PointerPreparations.h>
78#include <wtf/URL.h>
79
80#if ENABLE(APPLE_PAY)
81#include "JSMockPaymentCoordinator.h"
82#endif
83
84#if ENABLE(CONTENT_FILTERING)
85#include "JSMockContentFilterSettings.h"
86#endif
87
88#if ENABLE(ENCRYPTED_MEDIA)
89#include "JSMockCDMFactory.h"
90#endif
91
92#if ENABLE(MEDIA_SESSION)
93#include "JSMediaSession.h"
94#endif
95
96#if ENABLE(MEDIA_SESSION) || ENABLE(VIDEO)
97#include "JSHTMLMediaElement.h"
98#endif
99
100#if ENABLE(MEDIA_SOURCE)
101#include "JSSourceBuffer.h"
102#endif
103
104#if ENABLE(MEDIA_STREAM)
105#include "JSMediaStream.h"
106#include "JSMediaStreamTrack.h"
107#endif
108
109#if ENABLE(SERVICE_WORKER)
110#include "JSServiceWorker.h"
111#endif
112
113#if ENABLE(VIDEO)
114#include "JSTimeRanges.h"
115#endif
116
117#if ENABLE(VIDEO_TRACK)
118#include "JSTextTrackCueGeneric.h"
119#endif
120
121#if ENABLE(WEBGL)
122#include "JSWebGLRenderingContext.h"
123#endif
124
125#if ENABLE(WEB_AUDIO)
126#include "JSAudioContext.h"
127#endif
128
129#if ENABLE(WEB_RTC)
130#include "JSRTCPeerConnection.h"
131#endif
132
133
134namespace WebCore {
135using namespace JSC;
136
137String convertEnumerationToString(Internals::PageOverlayType enumerationValue)
138{
139 static const NeverDestroyed<String> values[] = {
140 MAKE_STATIC_STRING_IMPL("view"),
141 MAKE_STATIC_STRING_IMPL("document"),
142 };
143 static_assert(static_cast<size_t>(Internals::PageOverlayType::View) == 0, "Internals::PageOverlayType::View is not 0 as expected");
144 static_assert(static_cast<size_t>(Internals::PageOverlayType::Document) == 1, "Internals::PageOverlayType::Document is not 1 as expected");
145 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
146 return values[static_cast<size_t>(enumerationValue)];
147}
148
149template<> JSString* convertEnumerationToJS(ExecState& state, Internals::PageOverlayType enumerationValue)
150{
151 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
152}
153
154template<> Optional<Internals::PageOverlayType> parseEnumeration<Internals::PageOverlayType>(ExecState& state, JSValue value)
155{
156 auto stringValue = value.toWTFString(&state);
157 if (stringValue == "view")
158 return Internals::PageOverlayType::View;
159 if (stringValue == "document")
160 return Internals::PageOverlayType::Document;
161 return WTF::nullopt;
162}
163
164template<> const char* expectedEnumerationValues<Internals::PageOverlayType>()
165{
166 return "\"view\", \"document\"";
167}
168
169String convertEnumerationToString(Internals::CachePolicy enumerationValue)
170{
171 static const NeverDestroyed<String> values[] = {
172 MAKE_STATIC_STRING_IMPL("UseProtocolCachePolicy"),
173 MAKE_STATIC_STRING_IMPL("ReloadIgnoringCacheData"),
174 MAKE_STATIC_STRING_IMPL("ReturnCacheDataElseLoad"),
175 MAKE_STATIC_STRING_IMPL("ReturnCacheDataDontLoad"),
176 };
177 static_assert(static_cast<size_t>(Internals::CachePolicy::UseProtocolCachePolicy) == 0, "Internals::CachePolicy::UseProtocolCachePolicy is not 0 as expected");
178 static_assert(static_cast<size_t>(Internals::CachePolicy::ReloadIgnoringCacheData) == 1, "Internals::CachePolicy::ReloadIgnoringCacheData is not 1 as expected");
179 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataElseLoad) == 2, "Internals::CachePolicy::ReturnCacheDataElseLoad is not 2 as expected");
180 static_assert(static_cast<size_t>(Internals::CachePolicy::ReturnCacheDataDontLoad) == 3, "Internals::CachePolicy::ReturnCacheDataDontLoad is not 3 as expected");
181 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
182 return values[static_cast<size_t>(enumerationValue)];
183}
184
185template<> JSString* convertEnumerationToJS(ExecState& state, Internals::CachePolicy enumerationValue)
186{
187 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
188}
189
190template<> Optional<Internals::CachePolicy> parseEnumeration<Internals::CachePolicy>(ExecState& state, JSValue value)
191{
192 auto stringValue = value.toWTFString(&state);
193 if (stringValue == "UseProtocolCachePolicy")
194 return Internals::CachePolicy::UseProtocolCachePolicy;
195 if (stringValue == "ReloadIgnoringCacheData")
196 return Internals::CachePolicy::ReloadIgnoringCacheData;
197 if (stringValue == "ReturnCacheDataElseLoad")
198 return Internals::CachePolicy::ReturnCacheDataElseLoad;
199 if (stringValue == "ReturnCacheDataDontLoad")
200 return Internals::CachePolicy::ReturnCacheDataDontLoad;
201 return WTF::nullopt;
202}
203
204template<> const char* expectedEnumerationValues<Internals::CachePolicy>()
205{
206 return "\"UseProtocolCachePolicy\", \"ReloadIgnoringCacheData\", \"ReturnCacheDataElseLoad\", \"ReturnCacheDataDontLoad\"";
207}
208
209String convertEnumerationToString(Internals::ResourceLoadPriority enumerationValue)
210{
211 static const NeverDestroyed<String> values[] = {
212 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryLow"),
213 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityLow"),
214 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityMedium"),
215 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityHigh"),
216 MAKE_STATIC_STRING_IMPL("ResourceLoadPriorityVeryHigh"),
217 };
218 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow) == 0, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow is not 0 as expected");
219 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityLow) == 1, "Internals::ResourceLoadPriority::ResourceLoadPriorityLow is not 1 as expected");
220 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityMedium) == 2, "Internals::ResourceLoadPriority::ResourceLoadPriorityMedium is not 2 as expected");
221 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityHigh) == 3, "Internals::ResourceLoadPriority::ResourceLoadPriorityHigh is not 3 as expected");
222 static_assert(static_cast<size_t>(Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh) == 4, "Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh is not 4 as expected");
223 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
224 return values[static_cast<size_t>(enumerationValue)];
225}
226
227template<> JSString* convertEnumerationToJS(ExecState& state, Internals::ResourceLoadPriority enumerationValue)
228{
229 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
230}
231
232template<> Optional<Internals::ResourceLoadPriority> parseEnumeration<Internals::ResourceLoadPriority>(ExecState& state, JSValue value)
233{
234 auto stringValue = value.toWTFString(&state);
235 if (stringValue == "ResourceLoadPriorityVeryLow")
236 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryLow;
237 if (stringValue == "ResourceLoadPriorityLow")
238 return Internals::ResourceLoadPriority::ResourceLoadPriorityLow;
239 if (stringValue == "ResourceLoadPriorityMedium")
240 return Internals::ResourceLoadPriority::ResourceLoadPriorityMedium;
241 if (stringValue == "ResourceLoadPriorityHigh")
242 return Internals::ResourceLoadPriority::ResourceLoadPriorityHigh;
243 if (stringValue == "ResourceLoadPriorityVeryHigh")
244 return Internals::ResourceLoadPriority::ResourceLoadPriorityVeryHigh;
245 return WTF::nullopt;
246}
247
248template<> const char* expectedEnumerationValues<Internals::ResourceLoadPriority>()
249{
250 return "\"ResourceLoadPriorityVeryLow\", \"ResourceLoadPriorityLow\", \"ResourceLoadPriorityMedium\", \"ResourceLoadPriorityHigh\", \"ResourceLoadPriorityVeryHigh\"";
251}
252
253#if ENABLE(MEDIA_SESSION)
254
255String convertEnumerationToString(Internals::MediaSessionInterruptingCategory enumerationValue)
256{
257 static const NeverDestroyed<String> values[] = {
258 MAKE_STATIC_STRING_IMPL("content"),
259 MAKE_STATIC_STRING_IMPL("transient"),
260 MAKE_STATIC_STRING_IMPL("transient-solo"),
261 };
262 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::Content) == 0, "Internals::MediaSessionInterruptingCategory::Content is not 0 as expected");
263 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::Transient) == 1, "Internals::MediaSessionInterruptingCategory::Transient is not 1 as expected");
264 static_assert(static_cast<size_t>(Internals::MediaSessionInterruptingCategory::TransientSolo) == 2, "Internals::MediaSessionInterruptingCategory::TransientSolo is not 2 as expected");
265 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
266 return values[static_cast<size_t>(enumerationValue)];
267}
268
269template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaSessionInterruptingCategory enumerationValue)
270{
271 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
272}
273
274template<> Optional<Internals::MediaSessionInterruptingCategory> parseEnumeration<Internals::MediaSessionInterruptingCategory>(ExecState& state, JSValue value)
275{
276 auto stringValue = value.toWTFString(&state);
277 if (stringValue == "content")
278 return Internals::MediaSessionInterruptingCategory::Content;
279 if (stringValue == "transient")
280 return Internals::MediaSessionInterruptingCategory::Transient;
281 if (stringValue == "transient-solo")
282 return Internals::MediaSessionInterruptingCategory::TransientSolo;
283 return WTF::nullopt;
284}
285
286template<> const char* expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()
287{
288 return "\"content\", \"transient\", \"transient-solo\"";
289}
290
291#endif
292
293#if ENABLE(MEDIA_SESSION)
294
295String convertEnumerationToString(Internals::MediaControlEvent enumerationValue)
296{
297 static const NeverDestroyed<String> values[] = {
298 MAKE_STATIC_STRING_IMPL("play-pause"),
299 MAKE_STATIC_STRING_IMPL("next-track"),
300 MAKE_STATIC_STRING_IMPL("previous-track"),
301 };
302 static_assert(static_cast<size_t>(Internals::MediaControlEvent::PlayPause) == 0, "Internals::MediaControlEvent::PlayPause is not 0 as expected");
303 static_assert(static_cast<size_t>(Internals::MediaControlEvent::NextTrack) == 1, "Internals::MediaControlEvent::NextTrack is not 1 as expected");
304 static_assert(static_cast<size_t>(Internals::MediaControlEvent::PreviousTrack) == 2, "Internals::MediaControlEvent::PreviousTrack is not 2 as expected");
305 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
306 return values[static_cast<size_t>(enumerationValue)];
307}
308
309template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaControlEvent enumerationValue)
310{
311 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
312}
313
314template<> Optional<Internals::MediaControlEvent> parseEnumeration<Internals::MediaControlEvent>(ExecState& state, JSValue value)
315{
316 auto stringValue = value.toWTFString(&state);
317 if (stringValue == "play-pause")
318 return Internals::MediaControlEvent::PlayPause;
319 if (stringValue == "next-track")
320 return Internals::MediaControlEvent::NextTrack;
321 if (stringValue == "previous-track")
322 return Internals::MediaControlEvent::PreviousTrack;
323 return WTF::nullopt;
324}
325
326template<> const char* expectedEnumerationValues<Internals::MediaControlEvent>()
327{
328 return "\"play-pause\", \"next-track\", \"previous-track\"";
329}
330
331#endif
332
333String convertEnumerationToString(Internals::AutoFillButtonType enumerationValue)
334{
335 static const NeverDestroyed<String> values[] = {
336 MAKE_STATIC_STRING_IMPL("None"),
337 MAKE_STATIC_STRING_IMPL("Contacts"),
338 MAKE_STATIC_STRING_IMPL("Credentials"),
339 MAKE_STATIC_STRING_IMPL("StrongPassword"),
340 MAKE_STATIC_STRING_IMPL("CreditCard"),
341 };
342 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::None) == 0, "Internals::AutoFillButtonType::None is not 0 as expected");
343 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Contacts) == 1, "Internals::AutoFillButtonType::Contacts is not 1 as expected");
344 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::Credentials) == 2, "Internals::AutoFillButtonType::Credentials is not 2 as expected");
345 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::StrongPassword) == 3, "Internals::AutoFillButtonType::StrongPassword is not 3 as expected");
346 static_assert(static_cast<size_t>(Internals::AutoFillButtonType::CreditCard) == 4, "Internals::AutoFillButtonType::CreditCard is not 4 as expected");
347 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
348 return values[static_cast<size_t>(enumerationValue)];
349}
350
351template<> JSString* convertEnumerationToJS(ExecState& state, Internals::AutoFillButtonType enumerationValue)
352{
353 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
354}
355
356template<> Optional<Internals::AutoFillButtonType> parseEnumeration<Internals::AutoFillButtonType>(ExecState& state, JSValue value)
357{
358 auto stringValue = value.toWTFString(&state);
359 if (stringValue == "None")
360 return Internals::AutoFillButtonType::None;
361 if (stringValue == "Contacts")
362 return Internals::AutoFillButtonType::Contacts;
363 if (stringValue == "Credentials")
364 return Internals::AutoFillButtonType::Credentials;
365 if (stringValue == "StrongPassword")
366 return Internals::AutoFillButtonType::StrongPassword;
367 if (stringValue == "CreditCard")
368 return Internals::AutoFillButtonType::CreditCard;
369 return WTF::nullopt;
370}
371
372template<> const char* expectedEnumerationValues<Internals::AutoFillButtonType>()
373{
374 return "\"None\", \"Contacts\", \"Credentials\", \"StrongPassword\", \"CreditCard\"";
375}
376
377String convertEnumerationToString(Internals::UserInterfaceLayoutDirection enumerationValue)
378{
379 static const NeverDestroyed<String> values[] = {
380 MAKE_STATIC_STRING_IMPL("LTR"),
381 MAKE_STATIC_STRING_IMPL("RTL"),
382 };
383 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::LTR) == 0, "Internals::UserInterfaceLayoutDirection::LTR is not 0 as expected");
384 static_assert(static_cast<size_t>(Internals::UserInterfaceLayoutDirection::RTL) == 1, "Internals::UserInterfaceLayoutDirection::RTL is not 1 as expected");
385 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
386 return values[static_cast<size_t>(enumerationValue)];
387}
388
389template<> JSString* convertEnumerationToJS(ExecState& state, Internals::UserInterfaceLayoutDirection enumerationValue)
390{
391 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
392}
393
394template<> Optional<Internals::UserInterfaceLayoutDirection> parseEnumeration<Internals::UserInterfaceLayoutDirection>(ExecState& state, JSValue value)
395{
396 auto stringValue = value.toWTFString(&state);
397 if (stringValue == "LTR")
398 return Internals::UserInterfaceLayoutDirection::LTR;
399 if (stringValue == "RTL")
400 return Internals::UserInterfaceLayoutDirection::RTL;
401 return WTF::nullopt;
402}
403
404template<> const char* expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()
405{
406 return "\"LTR\", \"RTL\"";
407}
408
409String convertEnumerationToString(Internals::BaseWritingDirection enumerationValue)
410{
411 static const NeverDestroyed<String> values[] = {
412 MAKE_STATIC_STRING_IMPL("Natural"),
413 MAKE_STATIC_STRING_IMPL("Ltr"),
414 MAKE_STATIC_STRING_IMPL("Rtl"),
415 };
416 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Natural) == 0, "Internals::BaseWritingDirection::Natural is not 0 as expected");
417 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Ltr) == 1, "Internals::BaseWritingDirection::Ltr is not 1 as expected");
418 static_assert(static_cast<size_t>(Internals::BaseWritingDirection::Rtl) == 2, "Internals::BaseWritingDirection::Rtl is not 2 as expected");
419 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
420 return values[static_cast<size_t>(enumerationValue)];
421}
422
423template<> JSString* convertEnumerationToJS(ExecState& state, Internals::BaseWritingDirection enumerationValue)
424{
425 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
426}
427
428template<> Optional<Internals::BaseWritingDirection> parseEnumeration<Internals::BaseWritingDirection>(ExecState& state, JSValue value)
429{
430 auto stringValue = value.toWTFString(&state);
431 if (stringValue == "Natural")
432 return Internals::BaseWritingDirection::Natural;
433 if (stringValue == "Ltr")
434 return Internals::BaseWritingDirection::Ltr;
435 if (stringValue == "Rtl")
436 return Internals::BaseWritingDirection::Rtl;
437 return WTF::nullopt;
438}
439
440template<> const char* expectedEnumerationValues<Internals::BaseWritingDirection>()
441{
442 return "\"Natural\", \"Ltr\", \"Rtl\"";
443}
444
445String convertEnumerationToString(Internals::EventThrottlingBehavior enumerationValue)
446{
447 static const NeverDestroyed<String> values[] = {
448 MAKE_STATIC_STRING_IMPL("responsive"),
449 MAKE_STATIC_STRING_IMPL("unresponsive"),
450 };
451 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Responsive) == 0, "Internals::EventThrottlingBehavior::Responsive is not 0 as expected");
452 static_assert(static_cast<size_t>(Internals::EventThrottlingBehavior::Unresponsive) == 1, "Internals::EventThrottlingBehavior::Unresponsive is not 1 as expected");
453 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
454 return values[static_cast<size_t>(enumerationValue)];
455}
456
457template<> JSString* convertEnumerationToJS(ExecState& state, Internals::EventThrottlingBehavior enumerationValue)
458{
459 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
460}
461
462template<> Optional<Internals::EventThrottlingBehavior> parseEnumeration<Internals::EventThrottlingBehavior>(ExecState& state, JSValue value)
463{
464 auto stringValue = value.toWTFString(&state);
465 if (stringValue == "responsive")
466 return Internals::EventThrottlingBehavior::Responsive;
467 if (stringValue == "unresponsive")
468 return Internals::EventThrottlingBehavior::Unresponsive;
469 return WTF::nullopt;
470}
471
472template<> const char* expectedEnumerationValues<Internals::EventThrottlingBehavior>()
473{
474 return "\"responsive\", \"unresponsive\"";
475}
476
477String convertEnumerationToString(Internals::CompositingPolicy enumerationValue)
478{
479 static const NeverDestroyed<String> values[] = {
480 MAKE_STATIC_STRING_IMPL("normal"),
481 MAKE_STATIC_STRING_IMPL("conservative"),
482 };
483 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Normal) == 0, "Internals::CompositingPolicy::Normal is not 0 as expected");
484 static_assert(static_cast<size_t>(Internals::CompositingPolicy::Conservative) == 1, "Internals::CompositingPolicy::Conservative is not 1 as expected");
485 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
486 return values[static_cast<size_t>(enumerationValue)];
487}
488
489template<> JSString* convertEnumerationToJS(ExecState& state, Internals::CompositingPolicy enumerationValue)
490{
491 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
492}
493
494template<> Optional<Internals::CompositingPolicy> parseEnumeration<Internals::CompositingPolicy>(ExecState& state, JSValue value)
495{
496 auto stringValue = value.toWTFString(&state);
497 if (stringValue == "normal")
498 return Internals::CompositingPolicy::Normal;
499 if (stringValue == "conservative")
500 return Internals::CompositingPolicy::Conservative;
501 return WTF::nullopt;
502}
503
504template<> const char* expectedEnumerationValues<Internals::CompositingPolicy>()
505{
506 return "\"normal\", \"conservative\"";
507}
508
509#if ENABLE(VIDEO)
510
511String convertEnumerationToString(Internals::PlaybackControlsPurpose enumerationValue)
512{
513 static const NeverDestroyed<String> values[] = {
514 MAKE_STATIC_STRING_IMPL("ControlsManager"),
515 MAKE_STATIC_STRING_IMPL("NowPlaying"),
516 };
517 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::ControlsManager) == 0, "Internals::PlaybackControlsPurpose::ControlsManager is not 0 as expected");
518 static_assert(static_cast<size_t>(Internals::PlaybackControlsPurpose::NowPlaying) == 1, "Internals::PlaybackControlsPurpose::NowPlaying is not 1 as expected");
519 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
520 return values[static_cast<size_t>(enumerationValue)];
521}
522
523template<> JSString* convertEnumerationToJS(ExecState& state, Internals::PlaybackControlsPurpose enumerationValue)
524{
525 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
526}
527
528template<> Optional<Internals::PlaybackControlsPurpose> parseEnumeration<Internals::PlaybackControlsPurpose>(ExecState& state, JSValue value)
529{
530 auto stringValue = value.toWTFString(&state);
531 if (stringValue == "ControlsManager")
532 return Internals::PlaybackControlsPurpose::ControlsManager;
533 if (stringValue == "NowPlaying")
534 return Internals::PlaybackControlsPurpose::NowPlaying;
535 return WTF::nullopt;
536}
537
538template<> const char* expectedEnumerationValues<Internals::PlaybackControlsPurpose>()
539{
540 return "\"ControlsManager\", \"NowPlaying\"";
541}
542
543#endif
544
545#if ENABLE(VIDEO)
546
547String convertEnumerationToString(Internals::MediaSessionState enumerationValue)
548{
549 static const NeverDestroyed<String> values[] = {
550 MAKE_STATIC_STRING_IMPL("Idle"),
551 MAKE_STATIC_STRING_IMPL("Autoplaying"),
552 MAKE_STATIC_STRING_IMPL("Playing"),
553 MAKE_STATIC_STRING_IMPL("Paused"),
554 MAKE_STATIC_STRING_IMPL("Interrupted"),
555 };
556 static_assert(static_cast<size_t>(Internals::MediaSessionState::Idle) == 0, "Internals::MediaSessionState::Idle is not 0 as expected");
557 static_assert(static_cast<size_t>(Internals::MediaSessionState::Autoplaying) == 1, "Internals::MediaSessionState::Autoplaying is not 1 as expected");
558 static_assert(static_cast<size_t>(Internals::MediaSessionState::Playing) == 2, "Internals::MediaSessionState::Playing is not 2 as expected");
559 static_assert(static_cast<size_t>(Internals::MediaSessionState::Paused) == 3, "Internals::MediaSessionState::Paused is not 3 as expected");
560 static_assert(static_cast<size_t>(Internals::MediaSessionState::Interrupted) == 4, "Internals::MediaSessionState::Interrupted is not 4 as expected");
561 ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
562 return values[static_cast<size_t>(enumerationValue)];
563}
564
565template<> JSString* convertEnumerationToJS(ExecState& state, Internals::MediaSessionState enumerationValue)
566{
567 return jsStringWithCache(&state, convertEnumerationToString(enumerationValue));
568}
569
570template<> Optional<Internals::MediaSessionState> parseEnumeration<Internals::MediaSessionState>(ExecState& state, JSValue value)
571{
572 auto stringValue = value.toWTFString(&state);
573 if (stringValue == "Idle")
574 return Internals::MediaSessionState::Idle;
575 if (stringValue == "Autoplaying")
576 return Internals::MediaSessionState::Autoplaying;
577 if (stringValue == "Playing")
578 return Internals::MediaSessionState::Playing;
579 if (stringValue == "Paused")
580 return Internals::MediaSessionState::Paused;
581 if (stringValue == "Interrupted")
582 return Internals::MediaSessionState::Interrupted;
583 return WTF::nullopt;
584}
585
586template<> const char* expectedEnumerationValues<Internals::MediaSessionState>()
587{
588 return "\"Idle\", \"Autoplaying\", \"Playing\", \"Paused\", \"Interrupted\"";
589}
590
591#endif
592
593#if ENABLE(VIDEO)
594
595template<> Internals::NowPlayingState convertDictionary<Internals::NowPlayingState>(ExecState& state, JSValue value)
596{
597 VM& vm = state.vm();
598 auto throwScope = DECLARE_THROW_SCOPE(vm);
599 bool isNullOrUndefined = value.isUndefinedOrNull();
600 auto* object = isNullOrUndefined ? nullptr : value.getObject();
601 if (UNLIKELY(!isNullOrUndefined && !object)) {
602 throwTypeError(&state, throwScope);
603 return { };
604 }
605 Internals::NowPlayingState result;
606 JSValue durationValue;
607 if (isNullOrUndefined)
608 durationValue = jsUndefined();
609 else {
610 durationValue = object->get(&state, Identifier::fromString(&state, "duration"));
611 RETURN_IF_EXCEPTION(throwScope, { });
612 }
613 if (!durationValue.isUndefined()) {
614 result.duration = convert<IDLUnrestrictedDouble>(state, durationValue);
615 RETURN_IF_EXCEPTION(throwScope, { });
616 }
617 JSValue elapsedTimeValue;
618 if (isNullOrUndefined)
619 elapsedTimeValue = jsUndefined();
620 else {
621 elapsedTimeValue = object->get(&state, Identifier::fromString(&state, "elapsedTime"));
622 RETURN_IF_EXCEPTION(throwScope, { });
623 }
624 if (!elapsedTimeValue.isUndefined()) {
625 result.elapsedTime = convert<IDLUnrestrictedDouble>(state, elapsedTimeValue);
626 RETURN_IF_EXCEPTION(throwScope, { });
627 }
628 JSValue hasActiveSessionValue;
629 if (isNullOrUndefined)
630 hasActiveSessionValue = jsUndefined();
631 else {
632 hasActiveSessionValue = object->get(&state, Identifier::fromString(&state, "hasActiveSession"));
633 RETURN_IF_EXCEPTION(throwScope, { });
634 }
635 if (!hasActiveSessionValue.isUndefined()) {
636 result.hasActiveSession = convert<IDLBoolean>(state, hasActiveSessionValue);
637 RETURN_IF_EXCEPTION(throwScope, { });
638 }
639 JSValue registeredAsNowPlayingApplicationValue;
640 if (isNullOrUndefined)
641 registeredAsNowPlayingApplicationValue = jsUndefined();
642 else {
643 registeredAsNowPlayingApplicationValue = object->get(&state, Identifier::fromString(&state, "registeredAsNowPlayingApplication"));
644 RETURN_IF_EXCEPTION(throwScope, { });
645 }
646 if (!registeredAsNowPlayingApplicationValue.isUndefined()) {
647 result.registeredAsNowPlayingApplication = convert<IDLBoolean>(state, registeredAsNowPlayingApplicationValue);
648 RETURN_IF_EXCEPTION(throwScope, { });
649 }
650 JSValue titleValue;
651 if (isNullOrUndefined)
652 titleValue = jsUndefined();
653 else {
654 titleValue = object->get(&state, Identifier::fromString(&state, "title"));
655 RETURN_IF_EXCEPTION(throwScope, { });
656 }
657 if (!titleValue.isUndefined()) {
658 result.title = convert<IDLDOMString>(state, titleValue);
659 RETURN_IF_EXCEPTION(throwScope, { });
660 }
661 JSValue uniqueIdentifierValue;
662 if (isNullOrUndefined)
663 uniqueIdentifierValue = jsUndefined();
664 else {
665 uniqueIdentifierValue = object->get(&state, Identifier::fromString(&state, "uniqueIdentifier"));
666 RETURN_IF_EXCEPTION(throwScope, { });
667 }
668 if (!uniqueIdentifierValue.isUndefined()) {
669 result.uniqueIdentifier = convert<IDLUnsignedLongLong>(state, uniqueIdentifierValue);
670 RETURN_IF_EXCEPTION(throwScope, { });
671 }
672 return result;
673}
674
675JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::NowPlayingState& dictionary)
676{
677 auto& vm = state.vm();
678
679 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
680
681 if (!IDLUnrestrictedDouble::isNullValue(dictionary.duration)) {
682 auto durationValue = toJS<IDLUnrestrictedDouble>(IDLUnrestrictedDouble::extractValueFromNullable(dictionary.duration));
683 result->putDirect(vm, JSC::Identifier::fromString(&vm, "duration"), durationValue);
684 }
685 if (!IDLUnrestrictedDouble::isNullValue(dictionary.elapsedTime)) {
686 auto elapsedTimeValue = toJS<IDLUnrestrictedDouble>(IDLUnrestrictedDouble::extractValueFromNullable(dictionary.elapsedTime));
687 result->putDirect(vm, JSC::Identifier::fromString(&vm, "elapsedTime"), elapsedTimeValue);
688 }
689 if (!IDLBoolean::isNullValue(dictionary.hasActiveSession)) {
690 auto hasActiveSessionValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.hasActiveSession));
691 result->putDirect(vm, JSC::Identifier::fromString(&vm, "hasActiveSession"), hasActiveSessionValue);
692 }
693 if (!IDLBoolean::isNullValue(dictionary.registeredAsNowPlayingApplication)) {
694 auto registeredAsNowPlayingApplicationValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.registeredAsNowPlayingApplication));
695 result->putDirect(vm, JSC::Identifier::fromString(&vm, "registeredAsNowPlayingApplication"), registeredAsNowPlayingApplicationValue);
696 }
697 if (!IDLDOMString::isNullValue(dictionary.title)) {
698 auto titleValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.title));
699 result->putDirect(vm, JSC::Identifier::fromString(&vm, "title"), titleValue);
700 }
701 if (!IDLUnsignedLongLong::isNullValue(dictionary.uniqueIdentifier)) {
702 auto uniqueIdentifierValue = toJS<IDLUnsignedLongLong>(IDLUnsignedLongLong::extractValueFromNullable(dictionary.uniqueIdentifier));
703 result->putDirect(vm, JSC::Identifier::fromString(&vm, "uniqueIdentifier"), uniqueIdentifierValue);
704 }
705 return result;
706}
707
708#endif
709
710template<> Internals::FullscreenInsets convertDictionary<Internals::FullscreenInsets>(ExecState& state, JSValue value)
711{
712 VM& vm = state.vm();
713 auto throwScope = DECLARE_THROW_SCOPE(vm);
714 bool isNullOrUndefined = value.isUndefinedOrNull();
715 auto* object = isNullOrUndefined ? nullptr : value.getObject();
716 if (UNLIKELY(!isNullOrUndefined && !object)) {
717 throwTypeError(&state, throwScope);
718 return { };
719 }
720 Internals::FullscreenInsets result;
721 JSValue bottomValue;
722 if (isNullOrUndefined)
723 bottomValue = jsUndefined();
724 else {
725 bottomValue = object->get(&state, Identifier::fromString(&state, "bottom"));
726 RETURN_IF_EXCEPTION(throwScope, { });
727 }
728 if (!bottomValue.isUndefined()) {
729 result.bottom = convert<IDLDouble>(state, bottomValue);
730 RETURN_IF_EXCEPTION(throwScope, { });
731 }
732 JSValue leftValue;
733 if (isNullOrUndefined)
734 leftValue = jsUndefined();
735 else {
736 leftValue = object->get(&state, Identifier::fromString(&state, "left"));
737 RETURN_IF_EXCEPTION(throwScope, { });
738 }
739 if (!leftValue.isUndefined()) {
740 result.left = convert<IDLDouble>(state, leftValue);
741 RETURN_IF_EXCEPTION(throwScope, { });
742 }
743 JSValue rightValue;
744 if (isNullOrUndefined)
745 rightValue = jsUndefined();
746 else {
747 rightValue = object->get(&state, Identifier::fromString(&state, "right"));
748 RETURN_IF_EXCEPTION(throwScope, { });
749 }
750 if (!rightValue.isUndefined()) {
751 result.right = convert<IDLDouble>(state, rightValue);
752 RETURN_IF_EXCEPTION(throwScope, { });
753 }
754 JSValue topValue;
755 if (isNullOrUndefined)
756 topValue = jsUndefined();
757 else {
758 topValue = object->get(&state, Identifier::fromString(&state, "top"));
759 RETURN_IF_EXCEPTION(throwScope, { });
760 }
761 if (!topValue.isUndefined()) {
762 result.top = convert<IDLDouble>(state, topValue);
763 RETURN_IF_EXCEPTION(throwScope, { });
764 }
765 return result;
766}
767
768JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::FullscreenInsets& dictionary)
769{
770 auto& vm = state.vm();
771
772 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
773
774 if (!IDLDouble::isNullValue(dictionary.bottom)) {
775 auto bottomValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.bottom));
776 result->putDirect(vm, JSC::Identifier::fromString(&vm, "bottom"), bottomValue);
777 }
778 if (!IDLDouble::isNullValue(dictionary.left)) {
779 auto leftValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.left));
780 result->putDirect(vm, JSC::Identifier::fromString(&vm, "left"), leftValue);
781 }
782 if (!IDLDouble::isNullValue(dictionary.right)) {
783 auto rightValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.right));
784 result->putDirect(vm, JSC::Identifier::fromString(&vm, "right"), rightValue);
785 }
786 if (!IDLDouble::isNullValue(dictionary.top)) {
787 auto topValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.top));
788 result->putDirect(vm, JSC::Identifier::fromString(&vm, "top"), topValue);
789 }
790 return result;
791}
792
793template<> Internals::HEVCParameterSet convertDictionary<Internals::HEVCParameterSet>(ExecState& state, JSValue value)
794{
795 VM& vm = state.vm();
796 auto throwScope = DECLARE_THROW_SCOPE(vm);
797 bool isNullOrUndefined = value.isUndefinedOrNull();
798 auto* object = isNullOrUndefined ? nullptr : value.getObject();
799 if (UNLIKELY(!isNullOrUndefined && !object)) {
800 throwTypeError(&state, throwScope);
801 return { };
802 }
803 Internals::HEVCParameterSet result;
804 JSValue codecNameValue;
805 if (isNullOrUndefined)
806 codecNameValue = jsUndefined();
807 else {
808 codecNameValue = object->get(&state, Identifier::fromString(&state, "codecName"));
809 RETURN_IF_EXCEPTION(throwScope, { });
810 }
811 if (!codecNameValue.isUndefined()) {
812 result.codecName = convert<IDLDOMString>(state, codecNameValue);
813 RETURN_IF_EXCEPTION(throwScope, { });
814 }
815 JSValue constraintFlagsValue;
816 if (isNullOrUndefined)
817 constraintFlagsValue = jsUndefined();
818 else {
819 constraintFlagsValue = object->get(&state, Identifier::fromString(&state, "constraintFlags"));
820 RETURN_IF_EXCEPTION(throwScope, { });
821 }
822 if (!constraintFlagsValue.isUndefined()) {
823 result.constraintFlags = convert<IDLSequence<IDLUnsignedShort>>(state, constraintFlagsValue);
824 RETURN_IF_EXCEPTION(throwScope, { });
825 }
826 JSValue generalLevelIDCValue;
827 if (isNullOrUndefined)
828 generalLevelIDCValue = jsUndefined();
829 else {
830 generalLevelIDCValue = object->get(&state, Identifier::fromString(&state, "generalLevelIDC"));
831 RETURN_IF_EXCEPTION(throwScope, { });
832 }
833 if (!generalLevelIDCValue.isUndefined()) {
834 result.generalLevelIDC = convert<IDLUnsignedShort>(state, generalLevelIDCValue);
835 RETURN_IF_EXCEPTION(throwScope, { });
836 }
837 JSValue generalProfileCompatibilityFlagsValue;
838 if (isNullOrUndefined)
839 generalProfileCompatibilityFlagsValue = jsUndefined();
840 else {
841 generalProfileCompatibilityFlagsValue = object->get(&state, Identifier::fromString(&state, "generalProfileCompatibilityFlags"));
842 RETURN_IF_EXCEPTION(throwScope, { });
843 }
844 if (!generalProfileCompatibilityFlagsValue.isUndefined()) {
845 result.generalProfileCompatibilityFlags = convert<IDLUnsignedLong>(state, generalProfileCompatibilityFlagsValue);
846 RETURN_IF_EXCEPTION(throwScope, { });
847 }
848 JSValue generalProfileIDCValue;
849 if (isNullOrUndefined)
850 generalProfileIDCValue = jsUndefined();
851 else {
852 generalProfileIDCValue = object->get(&state, Identifier::fromString(&state, "generalProfileIDC"));
853 RETURN_IF_EXCEPTION(throwScope, { });
854 }
855 if (!generalProfileIDCValue.isUndefined()) {
856 result.generalProfileIDC = convert<IDLUnsignedShort>(state, generalProfileIDCValue);
857 RETURN_IF_EXCEPTION(throwScope, { });
858 }
859 JSValue generalProfileSpaceValue;
860 if (isNullOrUndefined)
861 generalProfileSpaceValue = jsUndefined();
862 else {
863 generalProfileSpaceValue = object->get(&state, Identifier::fromString(&state, "generalProfileSpace"));
864 RETURN_IF_EXCEPTION(throwScope, { });
865 }
866 if (!generalProfileSpaceValue.isUndefined()) {
867 result.generalProfileSpace = convert<IDLUnsignedShort>(state, generalProfileSpaceValue);
868 RETURN_IF_EXCEPTION(throwScope, { });
869 }
870 JSValue generalTierFlagValue;
871 if (isNullOrUndefined)
872 generalTierFlagValue = jsUndefined();
873 else {
874 generalTierFlagValue = object->get(&state, Identifier::fromString(&state, "generalTierFlag"));
875 RETURN_IF_EXCEPTION(throwScope, { });
876 }
877 if (!generalTierFlagValue.isUndefined()) {
878 result.generalTierFlag = convert<IDLBoolean>(state, generalTierFlagValue);
879 RETURN_IF_EXCEPTION(throwScope, { });
880 }
881 return result;
882}
883
884JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::HEVCParameterSet& dictionary)
885{
886 auto& vm = state.vm();
887
888 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
889
890 if (!IDLDOMString::isNullValue(dictionary.codecName)) {
891 auto codecNameValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.codecName));
892 result->putDirect(vm, JSC::Identifier::fromString(&vm, "codecName"), codecNameValue);
893 }
894 if (!IDLSequence<IDLUnsignedShort>::isNullValue(dictionary.constraintFlags)) {
895 auto constraintFlagsValue = toJS<IDLSequence<IDLUnsignedShort>>(state, globalObject, IDLSequence<IDLUnsignedShort>::extractValueFromNullable(dictionary.constraintFlags));
896 result->putDirect(vm, JSC::Identifier::fromString(&vm, "constraintFlags"), constraintFlagsValue);
897 }
898 if (!IDLUnsignedShort::isNullValue(dictionary.generalLevelIDC)) {
899 auto generalLevelIDCValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalLevelIDC));
900 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalLevelIDC"), generalLevelIDCValue);
901 }
902 if (!IDLUnsignedLong::isNullValue(dictionary.generalProfileCompatibilityFlags)) {
903 auto generalProfileCompatibilityFlagsValue = toJS<IDLUnsignedLong>(IDLUnsignedLong::extractValueFromNullable(dictionary.generalProfileCompatibilityFlags));
904 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileCompatibilityFlags"), generalProfileCompatibilityFlagsValue);
905 }
906 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileIDC)) {
907 auto generalProfileIDCValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileIDC));
908 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileIDC"), generalProfileIDCValue);
909 }
910 if (!IDLUnsignedShort::isNullValue(dictionary.generalProfileSpace)) {
911 auto generalProfileSpaceValue = toJS<IDLUnsignedShort>(IDLUnsignedShort::extractValueFromNullable(dictionary.generalProfileSpace));
912 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalProfileSpace"), generalProfileSpaceValue);
913 }
914 if (!IDLBoolean::isNullValue(dictionary.generalTierFlag)) {
915 auto generalTierFlagValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.generalTierFlag));
916 result->putDirect(vm, JSC::Identifier::fromString(&vm, "generalTierFlag"), generalTierFlagValue);
917 }
918 return result;
919}
920
921template<> Internals::AcceleratedAnimation convertDictionary<Internals::AcceleratedAnimation>(ExecState& state, JSValue value)
922{
923 VM& vm = state.vm();
924 auto throwScope = DECLARE_THROW_SCOPE(vm);
925 bool isNullOrUndefined = value.isUndefinedOrNull();
926 auto* object = isNullOrUndefined ? nullptr : value.getObject();
927 if (UNLIKELY(!isNullOrUndefined && !object)) {
928 throwTypeError(&state, throwScope);
929 return { };
930 }
931 Internals::AcceleratedAnimation result;
932 JSValue propertyValue;
933 if (isNullOrUndefined)
934 propertyValue = jsUndefined();
935 else {
936 propertyValue = object->get(&state, Identifier::fromString(&state, "property"));
937 RETURN_IF_EXCEPTION(throwScope, { });
938 }
939 if (!propertyValue.isUndefined()) {
940 result.property = convert<IDLDOMString>(state, propertyValue);
941 RETURN_IF_EXCEPTION(throwScope, { });
942 }
943 JSValue speedValue;
944 if (isNullOrUndefined)
945 speedValue = jsUndefined();
946 else {
947 speedValue = object->get(&state, Identifier::fromString(&state, "speed"));
948 RETURN_IF_EXCEPTION(throwScope, { });
949 }
950 if (!speedValue.isUndefined()) {
951 result.speed = convert<IDLDouble>(state, speedValue);
952 RETURN_IF_EXCEPTION(throwScope, { });
953 }
954 return result;
955}
956
957JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::AcceleratedAnimation& dictionary)
958{
959 auto& vm = state.vm();
960
961 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
962
963 if (!IDLDOMString::isNullValue(dictionary.property)) {
964 auto propertyValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.property));
965 result->putDirect(vm, JSC::Identifier::fromString(&vm, "property"), propertyValue);
966 }
967 if (!IDLDouble::isNullValue(dictionary.speed)) {
968 auto speedValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.speed));
969 result->putDirect(vm, JSC::Identifier::fromString(&vm, "speed"), speedValue);
970 }
971 return result;
972}
973
974template<> Internals::CookieData convertDictionary<Internals::CookieData>(ExecState& state, JSValue value)
975{
976 VM& vm = state.vm();
977 auto throwScope = DECLARE_THROW_SCOPE(vm);
978 bool isNullOrUndefined = value.isUndefinedOrNull();
979 auto* object = isNullOrUndefined ? nullptr : value.getObject();
980 if (UNLIKELY(!isNullOrUndefined && !object)) {
981 throwTypeError(&state, throwScope);
982 return { };
983 }
984 Internals::CookieData result;
985 JSValue domainValue;
986 if (isNullOrUndefined)
987 domainValue = jsUndefined();
988 else {
989 domainValue = object->get(&state, Identifier::fromString(&state, "domain"));
990 RETURN_IF_EXCEPTION(throwScope, { });
991 }
992 if (!domainValue.isUndefined()) {
993 result.domain = convert<IDLDOMString>(state, domainValue);
994 RETURN_IF_EXCEPTION(throwScope, { });
995 }
996 JSValue expiresValue;
997 if (isNullOrUndefined)
998 expiresValue = jsUndefined();
999 else {
1000 expiresValue = object->get(&state, Identifier::fromString(&state, "expires"));
1001 RETURN_IF_EXCEPTION(throwScope, { });
1002 }
1003 if (!expiresValue.isUndefined()) {
1004 result.expires = convert<IDLDouble>(state, expiresValue);
1005 RETURN_IF_EXCEPTION(throwScope, { });
1006 }
1007 JSValue isHttpOnlyValue;
1008 if (isNullOrUndefined)
1009 isHttpOnlyValue = jsUndefined();
1010 else {
1011 isHttpOnlyValue = object->get(&state, Identifier::fromString(&state, "isHttpOnly"));
1012 RETURN_IF_EXCEPTION(throwScope, { });
1013 }
1014 if (!isHttpOnlyValue.isUndefined()) {
1015 result.isHttpOnly = convert<IDLBoolean>(state, isHttpOnlyValue);
1016 RETURN_IF_EXCEPTION(throwScope, { });
1017 }
1018 JSValue isSameSiteLaxValue;
1019 if (isNullOrUndefined)
1020 isSameSiteLaxValue = jsUndefined();
1021 else {
1022 isSameSiteLaxValue = object->get(&state, Identifier::fromString(&state, "isSameSiteLax"));
1023 RETURN_IF_EXCEPTION(throwScope, { });
1024 }
1025 if (!isSameSiteLaxValue.isUndefined()) {
1026 result.isSameSiteLax = convert<IDLBoolean>(state, isSameSiteLaxValue);
1027 RETURN_IF_EXCEPTION(throwScope, { });
1028 }
1029 JSValue isSameSiteStrictValue;
1030 if (isNullOrUndefined)
1031 isSameSiteStrictValue = jsUndefined();
1032 else {
1033 isSameSiteStrictValue = object->get(&state, Identifier::fromString(&state, "isSameSiteStrict"));
1034 RETURN_IF_EXCEPTION(throwScope, { });
1035 }
1036 if (!isSameSiteStrictValue.isUndefined()) {
1037 result.isSameSiteStrict = convert<IDLBoolean>(state, isSameSiteStrictValue);
1038 RETURN_IF_EXCEPTION(throwScope, { });
1039 }
1040 JSValue isSecureValue;
1041 if (isNullOrUndefined)
1042 isSecureValue = jsUndefined();
1043 else {
1044 isSecureValue = object->get(&state, Identifier::fromString(&state, "isSecure"));
1045 RETURN_IF_EXCEPTION(throwScope, { });
1046 }
1047 if (!isSecureValue.isUndefined()) {
1048 result.isSecure = convert<IDLBoolean>(state, isSecureValue);
1049 RETURN_IF_EXCEPTION(throwScope, { });
1050 }
1051 JSValue isSessionValue;
1052 if (isNullOrUndefined)
1053 isSessionValue = jsUndefined();
1054 else {
1055 isSessionValue = object->get(&state, Identifier::fromString(&state, "isSession"));
1056 RETURN_IF_EXCEPTION(throwScope, { });
1057 }
1058 if (!isSessionValue.isUndefined()) {
1059 result.isSession = convert<IDLBoolean>(state, isSessionValue);
1060 RETURN_IF_EXCEPTION(throwScope, { });
1061 }
1062 JSValue nameValue;
1063 if (isNullOrUndefined)
1064 nameValue = jsUndefined();
1065 else {
1066 nameValue = object->get(&state, Identifier::fromString(&state, "name"));
1067 RETURN_IF_EXCEPTION(throwScope, { });
1068 }
1069 if (!nameValue.isUndefined()) {
1070 result.name = convert<IDLDOMString>(state, nameValue);
1071 RETURN_IF_EXCEPTION(throwScope, { });
1072 }
1073 JSValue valueValue;
1074 if (isNullOrUndefined)
1075 valueValue = jsUndefined();
1076 else {
1077 valueValue = object->get(&state, Identifier::fromString(&state, "value"));
1078 RETURN_IF_EXCEPTION(throwScope, { });
1079 }
1080 if (!valueValue.isUndefined()) {
1081 result.value = convert<IDLDOMString>(state, valueValue);
1082 RETURN_IF_EXCEPTION(throwScope, { });
1083 }
1084 return result;
1085}
1086
1087JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const Internals::CookieData& dictionary)
1088{
1089 auto& vm = state.vm();
1090
1091 auto result = constructEmptyObject(&state, globalObject.objectPrototype());
1092
1093 if (!IDLDOMString::isNullValue(dictionary.domain)) {
1094 auto domainValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.domain));
1095 result->putDirect(vm, JSC::Identifier::fromString(&vm, "domain"), domainValue);
1096 }
1097 if (!IDLDouble::isNullValue(dictionary.expires)) {
1098 auto expiresValue = toJS<IDLDouble>(IDLDouble::extractValueFromNullable(dictionary.expires));
1099 result->putDirect(vm, JSC::Identifier::fromString(&vm, "expires"), expiresValue);
1100 }
1101 if (!IDLBoolean::isNullValue(dictionary.isHttpOnly)) {
1102 auto isHttpOnlyValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isHttpOnly));
1103 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isHttpOnly"), isHttpOnlyValue);
1104 }
1105 if (!IDLBoolean::isNullValue(dictionary.isSameSiteLax)) {
1106 auto isSameSiteLaxValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSameSiteLax));
1107 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSameSiteLax"), isSameSiteLaxValue);
1108 }
1109 if (!IDLBoolean::isNullValue(dictionary.isSameSiteStrict)) {
1110 auto isSameSiteStrictValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSameSiteStrict));
1111 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSameSiteStrict"), isSameSiteStrictValue);
1112 }
1113 if (!IDLBoolean::isNullValue(dictionary.isSecure)) {
1114 auto isSecureValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSecure));
1115 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSecure"), isSecureValue);
1116 }
1117 if (!IDLBoolean::isNullValue(dictionary.isSession)) {
1118 auto isSessionValue = toJS<IDLBoolean>(IDLBoolean::extractValueFromNullable(dictionary.isSession));
1119 result->putDirect(vm, JSC::Identifier::fromString(&vm, "isSession"), isSessionValue);
1120 }
1121 if (!IDLDOMString::isNullValue(dictionary.name)) {
1122 auto nameValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.name));
1123 result->putDirect(vm, JSC::Identifier::fromString(&vm, "name"), nameValue);
1124 }
1125 if (!IDLDOMString::isNullValue(dictionary.value)) {
1126 auto valueValue = toJS<IDLDOMString>(state, IDLDOMString::extractValueFromNullable(dictionary.value));
1127 result->putDirect(vm, JSC::Identifier::fromString(&vm, "value"), valueValue);
1128 }
1129 return result;
1130}
1131
1132// Functions
1133
1134JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddress(JSC::ExecState*);
1135JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodeNeedsStyleRecalc(JSC::ExecState*);
1136JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleChangeType(JSC::ExecState*);
1137JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDescription(JSC::ExecState*);
1138JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasPausedImageAnimations(JSC::ExecState*);
1139JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPaintingFrequently(JSC::ExecState*);
1140JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIncrementFrequentPaintCounter(JSC::ExecState*);
1141JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementRenderTreeAsText(JSC::ExecState*);
1142JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPreloaded(JSC::ExecState*);
1143JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsLoadingFromMemoryCache(JSC::ExecState*);
1144JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFetchResponseSource(JSC::ExecState*);
1145JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionXhrResponseSource(JSC::ExecState*);
1146JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSharingStyleSheetContents(JSC::ExecState*);
1147JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources(JSC::ExecState*);
1148JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearMemoryCache(JSC::ExecState*);
1149JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPruneMemoryCacheToSize(JSC::ExecState*);
1150JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages(JSC::ExecState*);
1151JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryCacheSize(JSC::ExecState*);
1152JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideCachePolicy(JSC::ExecState*);
1153JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority(JSC::ExecState*);
1154JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled(JSC::ExecState*);
1155JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPageCache(JSC::ExecState*);
1156JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageCacheSize(JSC::ExecState*);
1157JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo(JSC::ExecState*);
1158JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot(JSC::ExecState*);
1159JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRoot(JSC::ExecState*);
1160JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredStyleRulesCount(JSC::ExecState*);
1161JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredGroupRulesCount(JSC::ExecState*);
1162JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredKeyframesRulesCount(JSC::ExecState*);
1163JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRootType(JSC::ExecState*);
1164JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowPseudoId(JSC::ExecState*);
1165JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShadowPseudoId(JSC::ExecState*);
1166JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTreeScopeRootNode(JSC::ExecState*);
1167JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParentTreeScope(JSC::ExecState*);
1168JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount(JSC::ExecState*);
1169JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfActiveAnimations(JSC::ExecState*);
1170JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSuspendAnimations(JSC::ExecState*);
1171JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResumeAnimations(JSC::ExecState*);
1172JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAnimationsAreSuspended(JSC::ExecState*);
1173JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement(JSC::ExecState*);
1174JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement(JSC::ExecState*);
1175JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement(JSC::ExecState*);
1176JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement(JSC::ExecState*);
1177JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAcceleratedAnimationsForElement(JSC::ExecState*);
1178JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations(JSC::ExecState*);
1179JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPseudoElement(JSC::ExecState*);
1180JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisiblePlaceholder(JSC::ExecState*);
1181JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectColorInColorChooser(JSC::ExecState*);
1182JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem(JSC::ExecState*);
1183JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem(JSC::ExecState*);
1184JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAbsoluteCaretBounds(JSC::ExecState*);
1185JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsCaretBlinkingSuspended(JSC::ExecState*);
1186JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBoundingBox(JSC::ExecState*);
1187JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInspectorHighlightRects(JSC::ExecState*);
1188JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerCountForNode(JSC::ExecState*);
1189JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerRangeForNode(JSC::ExecState*);
1190JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerDescriptionForNode(JSC::ExecState*);
1191JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDumpMarkerRects(JSC::ExecState*);
1192JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddTextMatchMarker(JSC::ExecState*);
1193JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted(JSC::ExecState*);
1194JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateFontCache(JSC::ExecState*);
1195JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFontSmoothingEnabled(JSC::ExecState*);
1196JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetScrollViewPosition(JSC::ExecState*);
1197JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnconstrainedScrollTo(JSC::ExecState*);
1198JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayoutViewportRect(JSC::ExecState*);
1199JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisualViewportRect(JSC::ExecState*);
1200JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewIsTransparent(JSC::ExecState*);
1201JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionViewBaseBackgroundColor(JSC::ExecState*);
1202JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewBaseBackgroundColor(JSC::ExecState*);
1203JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPagination(JSC::ExecState*);
1204JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPaginationLineGridEnabled(JSC::ExecState*);
1205JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionConfigurationForViewport(JSC::ExecState*);
1206JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWasLastChangeUserEdit(JSC::ExecState*);
1207JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldAutoComplete(JSC::ExecState*);
1208JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutofilled(JSC::ExecState*);
1209JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAutoFillButton(JSC::ExecState*);
1210JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutoFillButtonType(JSC::ExecState*);
1211JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastAutoFillButtonType(JSC::ExecState*);
1212JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfString(JSC::ExecState*);
1213JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountMatchesForText(JSC::ExecState*);
1214JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountFindMatches(JSC::ExecState*);
1215JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutofillFieldName(JSC::ExecState*);
1216JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateControlTints(JSC::ExecState*);
1217JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollElementToRect(JSC::ExecState*);
1218JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeFromLocationAndLength(JSC::ExecState*);
1219JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLocationFromRange(JSC::ExecState*);
1220JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLengthFromRange(JSC::ExecState*);
1221JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsText(JSC::ExecState*);
1222JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator(JSC::ExecState*);
1223JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSubrange(JSC::ExecState*);
1224JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation(JSC::ExecState*);
1225JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfStringNearLocation(JSC::ExecState*);
1226JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDelegatesScrolling(JSC::ExecState*);
1227JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckRequestSequence(JSC::ExecState*);
1228JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence(JSC::ExecState*);
1229JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredLanguages(JSC::ExecState*);
1230JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredLanguages(JSC::ExecState*);
1231JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics(JSC::ExecState*);
1232JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic(JSC::ExecState*);
1233JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWheelEventHandlerCount(JSC::ExecState*);
1234JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventHandlerCount(JSC::ExecState*);
1235JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventRectsForEvent(JSC::ExecState*);
1236JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPassiveTouchEventListenerRects(JSC::ExecState*);
1237JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodesFromRect(JSC::ExecState*);
1238JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParserMetaData(JSC::ExecState*);
1239JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled(JSC::ExecState*);
1240JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasSpellingMarker(JSC::ExecState*);
1241JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasGrammarMarker(JSC::ExecState*);
1242JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasAutocorrectedMarker(JSC::ExecState*);
1243JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled(JSC::ExecState*);
1244JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled(JSC::ExecState*);
1245JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled(JSC::ExecState*);
1246JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled(JSC::ExecState*);
1247JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled(JSC::ExecState*);
1248JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled(JSC::ExecState*);
1249JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHandleAcceptedCandidate(JSC::ExecState*);
1250JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionChangeSelectionListType(JSC::ExecState*);
1251JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsOverwriteModeEnabled(JSC::ExecState*);
1252JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToggleOverwriteModeEnabled(JSC::ExecState*);
1253JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfScrollableAreas(JSC::ExecState*);
1254JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPageBoxVisible(JSC::ExecState*);
1255JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameIndex(JSC::ExecState*);
1256JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameCount(JSC::ExecState*);
1257JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameDurationAtIndex(JSC::ExecState*);
1258JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetImageFrameDecodingDuration(JSC::ExecState*);
1259JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResetImageAnimation(JSC::ExecState*);
1260JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsImageAnimating(JSC::ExecState*);
1261JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting(JSC::ExecState*);
1262JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageDecodeCount(JSC::ExecState*);
1263JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPdfDocumentCachingCount(JSC::ExecState*);
1264JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting(JSC::ExecState*);
1265JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting(JSC::ExecState*);
1266JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetGridMaxTracksLimit(JSC::ExecState*);
1267JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSVGAnimationsInterval(JSC::ExecState*);
1268JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerTreeAsText(JSC::ExecState*);
1269JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerIDForElement(JSC::ExecState*);
1270JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarOverlayStyle(JSC::ExecState*);
1271JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance(JSC::ExecState*);
1272JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollingStateTreeAsText(JSC::ExecState*);
1273JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMainThreadScrollingReasons(JSC::ExecState*);
1274JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNonFastScrollableRects(JSC::ExecState*);
1275JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRepaintRectsAsText(JSC::ExecState*);
1276JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing(JSC::ExecState*);
1277JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay(JSC::ExecState*);
1278JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisplayListForElement(JSC::ExecState*);
1279JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReplayDisplayListForElement(JSC::ExecState*);
1280JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGarbageCollectDocumentResources(JSC::ExecState*);
1281JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertAuthorCSS(JSC::ExecState*);
1282JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertUserCSS(JSC::ExecState*);
1283JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure(JSC::ExecState*);
1284JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedMemoryPressure(JSC::ExecState*);
1285JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIDBTransactions(JSC::ExecState*);
1286JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveNodes(JSC::ExecState*);
1287JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveDocuments(JSC::ExecState*);
1288JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReferencingNodeCount(JSC::ExecState*);
1289#if ENABLE(INTERSECTION_OBSERVER)
1290JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIntersectionObservers(JSC::ExecState*);
1291#endif
1292JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOpenDummyInspectorFrontend(JSC::ExecState*);
1293JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloseDummyInspectorFrontend(JSC::ExecState*);
1294JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetInspectorIsUnderTest(JSC::ExecState*);
1295JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCounterValue(JSC::ExecState*);
1296JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageNumber(JSC::ExecState*);
1297JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShortcutIconURLs(JSC::ExecState*);
1298JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfPages(JSC::ExecState*);
1299JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageProperty(JSC::ExecState*);
1300JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels(JSC::ExecState*);
1301JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageScaleFactor(JSC::ExecState*);
1302JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageScaleFactor(JSC::ExecState*);
1303JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageZoomFactor(JSC::ExecState*);
1304JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTextZoomFactor(JSC::ExecState*);
1305JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseFixedLayout(JSC::ExecState*);
1306JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFixedLayoutSize(JSC::ExecState*);
1307JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrinting(JSC::ExecState*);
1308JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewExposedRect(JSC::ExecState*);
1309JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHeaderHeight(JSC::ExecState*);
1310JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFooterHeight(JSC::ExecState*);
1311JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTopContentInset(JSC::ExecState*);
1312#if ENABLE(FULLSCREEN_API)
1313JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement(JSC::ExecState*);
1314#endif
1315#if ENABLE(FULLSCREEN_API)
1316JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement(JSC::ExecState*);
1317#endif
1318#if ENABLE(FULLSCREEN_API)
1319JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement(JSC::ExecState*);
1320#endif
1321#if ENABLE(FULLSCREEN_API)
1322JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement(JSC::ExecState*);
1323#endif
1324JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenInsets(JSC::ExecState*);
1325JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration(JSC::ExecState*);
1326JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenControlsHidden(JSC::ExecState*);
1327JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota(JSC::ExecState*);
1328JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy(JSC::ExecState*);
1329JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy(JSC::ExecState*);
1330JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol(JSC::ExecState*);
1331JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMallocStatistics(JSC::ExecState*);
1332JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTypeConversions(JSC::ExecState*);
1333JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryInfo(JSC::ExecState*);
1334JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetReferencedFilePaths(JSC::ExecState*);
1335JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingRepaints(JSC::ExecState*);
1336JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopTrackingRepaints(JSC::ExecState*);
1337JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingLayerFlushes(JSC::ExecState*);
1338JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerFlushCount(JSC::ExecState*);
1339JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsTimerThrottled(JSC::ExecState*);
1340JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled(JSC::ExecState*);
1341JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAreTimersThrottled(JSC::ExecState*);
1342JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLowPowerModeEnabled(JSC::ExecState*);
1343JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingStyleRecalcs(JSC::ExecState*);
1344JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleRecalcCount(JSC::ExecState*);
1345JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingCompositingUpdates(JSC::ExecState*);
1346JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCompositingUpdateCount(JSC::ExecState*);
1347JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(JSC::ExecState*);
1348JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentCursorInfo(JSC::ExecState*);
1349JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerTextForListItem(JSC::ExecState*);
1350JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToolTipFromElement(JSC::ExecState*);
1351JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeserializeBuffer(JSC::ExecState*);
1352JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSerializeObject(JSC::ExecState*);
1353JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsFromCurrentWorld(JSC::ExecState*);
1354JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesOverlayScrollbars(JSC::ExecState*);
1355JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesMockScrollAnimator(JSC::ExecState*);
1356JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionForceReload(JSC::ExecState*);
1357JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadExpiredOnly(JSC::ExecState*);
1358JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableAutoSizeMode(JSC::ExecState*);
1359#if ENABLE(VIDEO)
1360JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseSources(JSC::ExecState*);
1361#endif
1362#if ENABLE(VIDEO)
1363JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseContentRanges(JSC::ExecState*);
1364#endif
1365#if ENABLE(VIDEO)
1366JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateAudioInterruption(JSC::ExecState*);
1367#endif
1368#if ENABLE(VIDEO)
1369JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementHasCharacteristic(JSC::ExecState*);
1370#endif
1371#if ENABLE(VIDEO)
1372JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedHDCPError(JSC::ExecState*);
1373#endif
1374#if ENABLE(VIDEO)
1375JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedHDCPError(JSC::ExecState*);
1376#endif
1377#if ENABLE(VIDEO)
1378JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldBufferData(JSC::ExecState*);
1379#endif
1380#if ENABLE(VIDEO)
1381JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementBufferingPolicy(JSC::ExecState*);
1382#endif
1383#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1384JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockCDM(JSC::ExecState*);
1385#endif
1386#if ENABLE(ENCRYPTED_MEDIA)
1387JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterMockCDM(JSC::ExecState*);
1388#endif
1389JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockMediaCapabilities(JSC::ExecState*);
1390#if ENABLE(SPEECH_SYNTHESIS)
1391JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer(JSC::ExecState*);
1392#endif
1393JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetImageSourceURL(JSC::ExecState*);
1394#if ENABLE(VIDEO_TRACK)
1395JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCaptionsStyleSheetOverride(JSC::ExecState*);
1396#endif
1397#if ENABLE(VIDEO_TRACK)
1398JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride(JSC::ExecState*);
1399#endif
1400#if ENABLE(VIDEO_TRACK)
1401JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride(JSC::ExecState*);
1402#endif
1403#if ENABLE(VIDEO_TRACK)
1404JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionDisplayMode(JSC::ExecState*);
1405#endif
1406#if ENABLE(VIDEO_TRACK)
1407JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateGenericCue(JSC::ExecState*);
1408#endif
1409#if ENABLE(VIDEO)
1410JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateTimeRanges(JSC::ExecState*);
1411#endif
1412#if ENABLE(VIDEO)
1413JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClosestTimeToTimeRanges(JSC::ExecState*);
1414#endif
1415JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSelectPopupVisible(JSC::ExecState*);
1416JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured(JSC::ExecState*);
1417JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnavailablePluginReplacementText(JSC::ExecState*);
1418JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginSnapshotted(JSC::ExecState*);
1419JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold(JSC::ExecState*);
1420JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectionBounds(JSC::ExecState*);
1421JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSelectionWithoutValidation(JSC::ExecState*);
1422#if ENABLE(MEDIA_SOURCE)
1423JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockMediaSource(JSC::ExecState*);
1424#endif
1425#if ENABLE(MEDIA_SOURCE)
1426JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBufferedSamplesForTrackID(JSC::ExecState*);
1427#endif
1428#if ENABLE(MEDIA_SOURCE)
1429JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID(JSC::ExecState*);
1430#endif
1431#if ENABLE(MEDIA_SOURCE)
1432JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldGenerateTimestamps(JSC::ExecState*);
1433#endif
1434#if ENABLE(VIDEO)
1435JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginMediaSessionInterruption(JSC::ExecState*);
1436#endif
1437#if ENABLE(VIDEO)
1438JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndMediaSessionInterruption(JSC::ExecState*);
1439#endif
1440#if ENABLE(MEDIA_SESSION)
1441JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification(JSC::ExecState*);
1442#endif
1443#if ENABLE(MEDIA_SESSION)
1444JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification(JSC::ExecState*);
1445#endif
1446#if ENABLE(MEDIA_SESSION)
1447JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionCurrentState(JSC::ExecState*);
1448#endif
1449#if ENABLE(MEDIA_SESSION)
1450JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementPlayerVolume(JSC::ExecState*);
1451#endif
1452#if ENABLE(MEDIA_SESSION)
1453JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaControlEvent(JSC::ExecState*);
1454#endif
1455#if ENABLE(VIDEO)
1456JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillBecomeInactive(JSC::ExecState*);
1457#endif
1458#if ENABLE(VIDEO)
1459JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidBecomeActive(JSC::ExecState*);
1460#endif
1461#if ENABLE(VIDEO)
1462JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillEnterForeground(JSC::ExecState*);
1463#endif
1464#if ENABLE(VIDEO)
1465JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidEnterBackground(JSC::ExecState*);
1466#endif
1467#if ENABLE(VIDEO)
1468JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaSessionRestrictions(JSC::ExecState*);
1469#endif
1470#if ENABLE(VIDEO)
1471JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionRestrictions(JSC::ExecState*);
1472#endif
1473#if ENABLE(VIDEO)
1474JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaElementRestrictions(JSC::ExecState*);
1475#endif
1476#if ENABLE(WEB_AUDIO)
1477JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAudioContextRestrictions(JSC::ExecState*);
1478#endif
1479#if ENABLE(VIDEO)
1480JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostRemoteControlCommand(JSC::ExecState*);
1481#endif
1482#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1483JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled(JSC::ExecState*);
1484#endif
1485#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1486JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState(JSC::ExecState*);
1487#endif
1488#if ENABLE(MEDIA_STREAM)
1489JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled(JSC::ExecState*);
1490#endif
1491#if ENABLE(MEDIA_STREAM)
1492JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator(JSC::ExecState*);
1493#endif
1494#if ENABLE(WEB_RTC)
1495JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent(JSC::ExecState*);
1496#endif
1497#if ENABLE(WEB_RTC)
1498JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory(JSC::ExecState*);
1499#endif
1500#if ENABLE(WEB_RTC)
1501JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetICECandidateFiltering(JSC::ExecState*);
1502#endif
1503#if ENABLE(WEB_RTC)
1504JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled(JSC::ExecState*);
1505#endif
1506#if ENABLE(WEB_RTC)
1507JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopPeerConnection(JSC::ExecState*);
1508#endif
1509#if ENABLE(WEB_RTC)
1510JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPeerConnectionFactory(JSC::ExecState*);
1511#endif
1512#if ENABLE(VIDEO)
1513JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemSleep(JSC::ExecState*);
1514#endif
1515#if ENABLE(VIDEO)
1516JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemWake(JSC::ExecState*);
1517#endif
1518#if ENABLE(VIDEO)
1519JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep(JSC::ExecState*);
1520#endif
1521JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInstallMockPageOverlay(JSC::ExecState*);
1522JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText(JSC::ExecState*);
1523JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageMuted(JSC::ExecState*);
1524JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageMediaState(JSC::ExecState*);
1525JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageDefersLoading(JSC::ExecState*);
1526JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageDefersLoading(JSC::ExecState*);
1527JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateFile(JSC::ExecState*);
1528JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionQueueMicroTask(JSC::ExecState*);
1529JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestPreloaderSettingViewport(JSC::ExecState*);
1530#if ENABLE(CSS_SCROLL_SNAP)
1531JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollSnapOffsets(JSC::ExecState*);
1532#endif
1533#if ENABLE(CSS_SCROLL_SNAP)
1534JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled(JSC::ExecState*);
1535#endif
1536JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects(JSC::ExecState*);
1537#if ENABLE(VIDEO)
1538JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement(JSC::ExecState*);
1539#endif
1540JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserVisibleString(JSC::ExecState*);
1541JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAllPlugins(JSC::ExecState*);
1542#if ENABLE(STREAMS_API)
1543JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloneArrayBuffer(JSC::ExecState*);
1544#endif
1545#if ENABLE(STREAMS_API)
1546JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsReadableStreamDisturbed(JSC::ExecState*);
1547#endif
1548JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResourceLoadStatisticsForURL(JSC::ExecState*);
1549JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled(JSC::ExecState*);
1550JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCanShowModalDialogOverride(JSC::ExecState*);
1551JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComposedTreeAsText(JSC::ExecState*);
1552JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsProcessingUserGesture(JSC::ExecState*);
1553JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp(JSC::ExecState*);
1554JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWithUserGesture(JSC::ExecState*);
1555JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserIsInteracting(JSC::ExecState*);
1556JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveGC(JSC::ExecState*);
1557JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection(JSC::ExecState*);
1558JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetBaseWritingDirection(JSC::ExecState*);
1559JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPrefersReducedMotion(JSC::ExecState*);
1560JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReportBacktrace(JSC::ExecState*);
1561#if ENABLE(POINTER_LOCK)
1562JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPendingPointerLock(JSC::ExecState*);
1563#endif
1564#if ENABLE(POINTER_LOCK)
1565JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPointerLock(JSC::ExecState*);
1566#endif
1567JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAccessKeyModifiers(JSC::ExecState*);
1568JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetQuickLookPassword(JSC::ExecState*);
1569JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAsRunningUserScripts(JSC::ExecState*);
1570#if ENABLE(APPLE_PAY)
1571JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHasStartedApplePaySession(JSC::ExecState*);
1572#endif
1573JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay(JSC::ExecState*);
1574JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting(JSC::ExecState*);
1575#if ENABLE(WEBGL)
1576JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateWebGLContextChanged(JSC::ExecState*);
1577#endif
1578#if ENABLE(WEBGL)
1579JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFailNextGPUStatusCheck(JSC::ExecState*);
1580#endif
1581#if ENABLE(WEBGL)
1582JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs(JSC::ExecState*);
1583#endif
1584JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageVisibility(JSC::ExecState*);
1585JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageIsFocusedAndActive(JSC::ExecState*);
1586#if ENABLE(WEB_RTC)
1587JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed(JSC::ExecState*);
1588#endif
1589#if ENABLE(WEB_RTC)
1590JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources(JSC::ExecState*);
1591#endif
1592#if ENABLE(MEDIA_STREAM)
1593JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation(JSC::ExecState*);
1594#endif
1595#if ENABLE(MEDIA_STREAM)
1596JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveMediaStreamTrack(JSC::ExecState*);
1597#endif
1598#if ENABLE(MEDIA_STREAM)
1599JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame(JSC::ExecState*);
1600#endif
1601#if ENABLE(MEDIA_STREAM)
1602JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples(JSC::ExecState*);
1603#endif
1604#if ENABLE(MEDIA_STREAM)
1605JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackMuted(JSC::ExecState*);
1606#endif
1607#if ENABLE(MEDIA_STREAM)
1608JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveMediaStreamTrack(JSC::ExecState*);
1609#endif
1610#if ENABLE(MEDIA_STREAM)
1611JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure(JSC::ExecState*);
1612#endif
1613#if ENABLE(MEDIA_STREAM)
1614JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier(JSC::ExecState*);
1615#endif
1616#if ENABLE(MEDIA_STREAM)
1617JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted(JSC::ExecState*);
1618#endif
1619#if ENABLE(MEDIA_STREAM)
1620JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint(JSC::ExecState*);
1621#endif
1622JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDocumentIdentifier(JSC::ExecState*);
1623JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsDocumentAlive(JSC::ExecState*);
1624JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive(JSC::ExecState*);
1625JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionServiceWorkerClientIdentifier(JSC::ExecState*);
1626JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation(JSC::ExecState*);
1627JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCacheStorageEngineRepresentation(JSC::ExecState*);
1628JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResponseSizeWithPadding(JSC::ExecState*);
1629JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResponseSizeWithPadding(JSC::ExecState*);
1630JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage(JSC::ExecState*);
1631JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetConsoleMessageListener(JSC::ExecState*);
1632JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionCategory(JSC::ExecState*);
1633JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPreferredAudioBufferSize(JSC::ExecState*);
1634JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionActive(JSC::ExecState*);
1635#if ENABLE(SERVICE_WORKER)
1636JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerRegistration(JSC::ExecState*);
1637#endif
1638#if ENABLE(SERVICE_WORKER)
1639JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTerminateServiceWorker(JSC::ExecState*);
1640#endif
1641#if ENABLE(SERVICE_WORKER)
1642JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerConnection(JSC::ExecState*);
1643#endif
1644JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewLink(JSC::ExecState*);
1645JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewImage(JSC::ExecState*);
1646JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUsingAppleInternalSDK(JSC::ExecState*);
1647JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostTask(JSC::ExecState*);
1648JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkContextAsInsecure(JSC::ExecState*);
1649#if ENABLE(VIDEO)
1650JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager(JSC::ExecState*);
1651#endif
1652#if ENABLE(VIDEO)
1653JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionState(JSC::ExecState*);
1654#endif
1655JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOngoingLoadsDescriptions(JSC::ExecState*);
1656JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled(JSC::ExecState*);
1657JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadWithoutContentExtensions(JSC::ExecState*);
1658JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseSystemAppearance(JSC::ExecState*);
1659JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginCount(JSC::ExecState*);
1660JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNotifyResourceLoadObserver(JSC::ExecState*);
1661JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPrimaryScreenDisplayID(JSC::ExecState*);
1662JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCapsLockIsOn(JSC::ExecState*);
1663JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSupportsVCPEncoder(JSC::ExecState*);
1664JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParseHEVCCodecParameters(JSC::ExecState*);
1665JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCookies(JSC::ExecState*);
1666JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive(JSC::ExecState*);
1667JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessWillSuspend(JSC::ExecState*);
1668JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessDidResume(JSC::ExecState*);
1669JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestDictionaryLogging(JSC::ExecState*);
1670JSC::EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding(JSC::ExecState*);
1671
1672// Attributes
1673
1674JSC::EncodedJSValue jsInternalsAnimationsInterval(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1675JSC::EncodedJSValue jsInternalsSentenceRetroCorrectionEnabled(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1676JSC::EncodedJSValue jsInternalsSettings(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1677JSC::EncodedJSValue jsInternalsWorkerThreadCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1678JSC::EncodedJSValue jsInternalsAreSVGAnimationsPaused(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1679JSC::EncodedJSValue jsInternalsIsUnderMemoryPressure(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1680#if ENABLE(FULLSCREEN_API)
1681JSC::EncodedJSValue jsInternalsIsAnimatingFullScreen(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1682#endif
1683JSC::EncodedJSValue jsInternalsRequestAnimationFrameInterval(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1684JSC::EncodedJSValue jsInternalsScriptedAnimationsAreSuspended(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1685JSC::EncodedJSValue jsInternalsEventThrottlingBehaviorOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1686bool setJSInternalsEventThrottlingBehaviorOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
1687JSC::EncodedJSValue jsInternalsLastStyleUpdateSize(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1688JSC::EncodedJSValue jsInternalsCompositingPolicyOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1689bool setJSInternalsCompositingPolicyOverride(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
1690JSC::EncodedJSValue jsInternalsLayoutCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1691#if ENABLE(CONTENT_FILTERING)
1692JSC::EncodedJSValue jsInternalsMockContentFilterSettings(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1693#endif
1694#if ENABLE(MEDIA_STREAM)
1695JSC::EncodedJSValue jsInternalsTrackAudioSampleCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1696#endif
1697#if ENABLE(MEDIA_STREAM)
1698JSC::EncodedJSValue jsInternalsTrackVideoSampleCount(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1699#endif
1700#if ENABLE(APPLE_PAY)
1701JSC::EncodedJSValue jsInternalsMockPaymentCoordinator(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1702#endif
1703#if ENABLE(VIDEO)
1704JSC::EncodedJSValue jsInternalsNowPlayingState(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
1705#endif
1706
1707class JSInternalsPrototype : public JSC::JSNonFinalObject {
1708public:
1709 using Base = JSC::JSNonFinalObject;
1710 static JSInternalsPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
1711 {
1712 JSInternalsPrototype* ptr = new (NotNull, JSC::allocateCell<JSInternalsPrototype>(vm.heap)) JSInternalsPrototype(vm, globalObject, structure);
1713 ptr->finishCreation(vm);
1714 return ptr;
1715 }
1716
1717 DECLARE_INFO;
1718 static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
1719 {
1720 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
1721 }
1722
1723private:
1724 JSInternalsPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
1725 : JSC::JSNonFinalObject(vm, structure)
1726 {
1727 }
1728
1729 void finishCreation(JSC::VM&);
1730};
1731
1732/* Hash table for prototype */
1733
1734static const HashTableValue JSInternalsPrototypeTableValues[] =
1735{
1736 { "animationsInterval", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsAnimationsInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1737 { "sentenceRetroCorrectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsSentenceRetroCorrectionEnabled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1738 { "settings", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsSettings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1739 { "workerThreadCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsWorkerThreadCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1740 { "areSVGAnimationsPaused", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsAreSVGAnimationsPaused), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1741 { "isUnderMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsIsUnderMemoryPressure), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1742#if ENABLE(FULLSCREEN_API)
1743 { "isAnimatingFullScreen", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsIsAnimatingFullScreen), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1744#else
1745 { 0, 0, NoIntrinsic, { 0, 0 } },
1746#endif
1747 { "requestAnimationFrameInterval", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsRequestAnimationFrameInterval), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1748 { "scriptedAnimationsAreSuspended", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsScriptedAnimationsAreSuspended), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1749 { "eventThrottlingBehaviorOverride", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsEventThrottlingBehaviorOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternalsEventThrottlingBehaviorOverride) } },
1750 { "lastStyleUpdateSize", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsLastStyleUpdateSize), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1751 { "compositingPolicyOverride", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsCompositingPolicyOverride), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSInternalsCompositingPolicyOverride) } },
1752 { "layoutCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsLayoutCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1753#if ENABLE(CONTENT_FILTERING)
1754 { "mockContentFilterSettings", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsMockContentFilterSettings), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1755#else
1756 { 0, 0, NoIntrinsic, { 0, 0 } },
1757#endif
1758#if ENABLE(MEDIA_STREAM)
1759 { "trackAudioSampleCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsTrackAudioSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1760#else
1761 { 0, 0, NoIntrinsic, { 0, 0 } },
1762#endif
1763#if ENABLE(MEDIA_STREAM)
1764 { "trackVideoSampleCount", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsTrackVideoSampleCount), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1765#else
1766 { 0, 0, NoIntrinsic, { 0, 0 } },
1767#endif
1768#if ENABLE(APPLE_PAY)
1769 { "mockPaymentCoordinator", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsMockPaymentCoordinator), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1770#else
1771 { 0, 0, NoIntrinsic, { 0, 0 } },
1772#endif
1773#if ENABLE(VIDEO)
1774 { "nowPlayingState", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsInternalsNowPlayingState), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1775#else
1776 { 0, 0, NoIntrinsic, { 0, 0 } },
1777#endif
1778 { "address", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAddress), (intptr_t) (1) } },
1779 { "nodeNeedsStyleRecalc", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNodeNeedsStyleRecalc), (intptr_t) (1) } },
1780 { "styleChangeType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStyleChangeType), (intptr_t) (1) } },
1781 { "description", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDescription), (intptr_t) (1) } },
1782 { "hasPausedImageAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasPausedImageAnimations), (intptr_t) (1) } },
1783 { "isPaintingFrequently", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPaintingFrequently), (intptr_t) (1) } },
1784 { "incrementFrequentPaintCounter", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIncrementFrequentPaintCounter), (intptr_t) (1) } },
1785 { "elementRenderTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementRenderTreeAsText), (intptr_t) (1) } },
1786 { "isPreloaded", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPreloaded), (intptr_t) (1) } },
1787 { "isLoadingFromMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsLoadingFromMemoryCache), (intptr_t) (1) } },
1788 { "fetchResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFetchResponseSource), (intptr_t) (1) } },
1789 { "xhrResponseSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionXhrResponseSource), (intptr_t) (1) } },
1790 { "isSharingStyleSheetContents", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSharingStyleSheetContents), (intptr_t) (2) } },
1791 { "isStyleSheetLoadingSubresources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources), (intptr_t) (1) } },
1792 { "clearMemoryCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearMemoryCache), (intptr_t) (0) } },
1793 { "pruneMemoryCacheToSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPruneMemoryCacheToSize), (intptr_t) (1) } },
1794 { "destroyDecodedDataForAllImages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages), (intptr_t) (0) } },
1795 { "memoryCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMemoryCacheSize), (intptr_t) (0) } },
1796 { "setOverrideCachePolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetOverrideCachePolicy), (intptr_t) (1) } },
1797 { "setOverrideResourceLoadPriority", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority), (intptr_t) (1) } },
1798 { "setStrictRawResourceValidationPolicyDisabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled), (intptr_t) (1) } },
1799 { "clearPageCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearPageCache), (intptr_t) (0) } },
1800 { "pageCacheSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageCacheSize), (intptr_t) (0) } },
1801 { "computedStyleIncludingVisitedInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo), (intptr_t) (1) } },
1802 { "ensureUserAgentShadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot), (intptr_t) (1) } },
1803 { "shadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowRoot), (intptr_t) (1) } },
1804 { "deferredStyleRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredStyleRulesCount), (intptr_t) (1) } },
1805 { "deferredGroupRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredGroupRulesCount), (intptr_t) (1) } },
1806 { "deferredKeyframesRulesCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeferredKeyframesRulesCount), (intptr_t) (1) } },
1807 { "shadowRootType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowRootType), (intptr_t) (1) } },
1808 { "shadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShadowPseudoId), (intptr_t) (1) } },
1809 { "setShadowPseudoId", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShadowPseudoId), (intptr_t) (2) } },
1810 { "treeScopeRootNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTreeScopeRootNode), (intptr_t) (1) } },
1811 { "parentTreeScope", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParentTreeScope), (intptr_t) (1) } },
1812 { "lastSpatialNavigationCandidateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount), (intptr_t) (0) } },
1813 { "numberOfActiveAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfActiveAnimations), (intptr_t) (0) } },
1814 { "suspendAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSuspendAnimations), (intptr_t) (0) } },
1815 { "resumeAnimations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResumeAnimations), (intptr_t) (0) } },
1816 { "animationsAreSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAnimationsAreSuspended), (intptr_t) (0) } },
1817 { "pauseAnimationAtTimeOnElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement), (intptr_t) (3) } },
1818 { "pauseAnimationAtTimeOnPseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement), (intptr_t) (4) } },
1819 { "pauseTransitionAtTimeOnElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement), (intptr_t) (3) } },
1820 { "pauseTransitionAtTimeOnPseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement), (intptr_t) (4) } },
1821 { "acceleratedAnimationsForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAcceleratedAnimationsForElement), (intptr_t) (1) } },
1822 { "numberOfAnimationTimelineInvalidations", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations), (intptr_t) (0) } },
1823 { "pseudoElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPseudoElement), (intptr_t) (2) } },
1824 { "visiblePlaceholder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionVisiblePlaceholder), (intptr_t) (1) } },
1825 { "selectColorInColorChooser", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSelectColorInColorChooser), (intptr_t) (2) } },
1826 { "formControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem), (intptr_t) (0) } },
1827 { "setFormControlStateOfPreviousHistoryItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem), (intptr_t) (1) } },
1828 { "absoluteCaretBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAbsoluteCaretBounds), (intptr_t) (0) } },
1829 { "isCaretBlinkingSuspended", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsCaretBlinkingSuspended), (intptr_t) (0) } },
1830 { "boundingBox", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBoundingBox), (intptr_t) (1) } },
1831 { "inspectorHighlightRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInspectorHighlightRects), (intptr_t) (0) } },
1832 { "markerCountForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerCountForNode), (intptr_t) (2) } },
1833 { "markerRangeForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerRangeForNode), (intptr_t) (3) } },
1834 { "markerDescriptionForNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerDescriptionForNode), (intptr_t) (3) } },
1835 { "dumpMarkerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDumpMarkerRects), (intptr_t) (1) } },
1836 { "addTextMatchMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAddTextMatchMarker), (intptr_t) (2) } },
1837 { "setMarkedTextMatchesAreHighlighted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted), (intptr_t) (1) } },
1838 { "invalidateFontCache", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInvalidateFontCache), (intptr_t) (0) } },
1839 { "setFontSmoothingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFontSmoothingEnabled), (intptr_t) (1) } },
1840 { "setScrollViewPosition", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetScrollViewPosition), (intptr_t) (2) } },
1841 { "unconstrainedScrollTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUnconstrainedScrollTo), (intptr_t) (3) } },
1842 { "layoutViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayoutViewportRect), (intptr_t) (0) } },
1843 { "visualViewportRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionVisualViewportRect), (intptr_t) (0) } },
1844 { "setViewIsTransparent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewIsTransparent), (intptr_t) (1) } },
1845 { "viewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionViewBaseBackgroundColor), (intptr_t) (0) } },
1846 { "setViewBaseBackgroundColor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewBaseBackgroundColor), (intptr_t) (1) } },
1847 { "setPagination", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPagination), (intptr_t) (2) } },
1848 { "setPaginationLineGridEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPaginationLineGridEnabled), (intptr_t) (1) } },
1849 { "configurationForViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionConfigurationForViewport), (intptr_t) (5) } },
1850 { "wasLastChangeUserEdit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWasLastChangeUserEdit), (intptr_t) (1) } },
1851 { "elementShouldAutoComplete", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementShouldAutoComplete), (intptr_t) (1) } },
1852 { "setAutofilled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutofilled), (intptr_t) (2) } },
1853 { "setShowAutoFillButton", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShowAutoFillButton), (intptr_t) (2) } },
1854 { "autoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAutoFillButtonType), (intptr_t) (1) } },
1855 { "lastAutoFillButtonType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastAutoFillButtonType), (intptr_t) (1) } },
1856 { "rangeOfString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeOfString), (intptr_t) (3) } },
1857 { "countMatchesForText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCountMatchesForText), (intptr_t) (3) } },
1858 { "countFindMatches", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCountFindMatches), (intptr_t) (2) } },
1859 { "autofillFieldName", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAutofillFieldName), (intptr_t) (1) } },
1860 { "invalidateControlTints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInvalidateControlTints), (intptr_t) (0) } },
1861 { "scrollElementToRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollElementToRect), (intptr_t) (5) } },
1862 { "rangeFromLocationAndLength", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeFromLocationAndLength), (intptr_t) (3) } },
1863 { "locationFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLocationFromRange), (intptr_t) (2) } },
1864 { "lengthFromRange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLengthFromRange), (intptr_t) (2) } },
1865 { "rangeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeAsText), (intptr_t) (1) } },
1866 { "rangeAsTextUsingBackwardsTextIterator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator), (intptr_t) (1) } },
1867 { "subrange", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSubrange), (intptr_t) (3) } },
1868 { "rangeForDictionaryLookupAtLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation), (intptr_t) (2) } },
1869 { "rangeOfStringNearLocation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRangeOfStringNearLocation), (intptr_t) (3) } },
1870 { "setDelegatesScrolling", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetDelegatesScrolling), (intptr_t) (1) } },
1871 { "lastSpellCheckRequestSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpellCheckRequestSequence), (intptr_t) (0) } },
1872 { "lastSpellCheckProcessedSequence", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence), (intptr_t) (0) } },
1873 { "userPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPreferredLanguages), (intptr_t) (0) } },
1874 { "setUserPreferredLanguages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserPreferredLanguages), (intptr_t) (1) } },
1875 { "userPreferredAudioCharacteristics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics), (intptr_t) (0) } },
1876 { "setUserPreferredAudioCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic), (intptr_t) (1) } },
1877 { "wheelEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWheelEventHandlerCount), (intptr_t) (0) } },
1878 { "touchEventHandlerCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTouchEventHandlerCount), (intptr_t) (0) } },
1879 { "touchEventRectsForEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTouchEventRectsForEvent), (intptr_t) (1) } },
1880 { "passiveTouchEventListenerRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPassiveTouchEventListenerRects), (intptr_t) (0) } },
1881 { "nodesFromRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNodesFromRect), (intptr_t) (10) } },
1882 { "parserMetaData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParserMetaData), (intptr_t) (0) } },
1883 { "updateEditorUINowIfScheduled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled), (intptr_t) (0) } },
1884 { "hasSpellingMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasSpellingMarker), (intptr_t) (2) } },
1885 { "hasGrammarMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasGrammarMarker), (intptr_t) (2) } },
1886 { "hasAutocorrectedMarker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasAutocorrectedMarker), (intptr_t) (2) } },
1887 { "setContinuousSpellCheckingEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled), (intptr_t) (1) } },
1888 { "setAutomaticQuoteSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled), (intptr_t) (1) } },
1889 { "setAutomaticLinkDetectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled), (intptr_t) (1) } },
1890 { "setAutomaticDashSubstitutionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled), (intptr_t) (1) } },
1891 { "setAutomaticTextReplacementEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled), (intptr_t) (1) } },
1892 { "setAutomaticSpellingCorrectionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled), (intptr_t) (1) } },
1893 { "handleAcceptedCandidate", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHandleAcceptedCandidate), (intptr_t) (3) } },
1894 { "changeSelectionListType", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionChangeSelectionListType), (intptr_t) (0) } },
1895 { "isOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsOverwriteModeEnabled), (intptr_t) (0) } },
1896 { "toggleOverwriteModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionToggleOverwriteModeEnabled), (intptr_t) (0) } },
1897 { "numberOfScrollableAreas", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfScrollableAreas), (intptr_t) (0) } },
1898 { "isPageBoxVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPageBoxVisible), (intptr_t) (1) } },
1899 { "imageFrameIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameIndex), (intptr_t) (1) } },
1900 { "imageFrameCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameCount), (intptr_t) (1) } },
1901 { "imageFrameDurationAtIndex", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageFrameDurationAtIndex), (intptr_t) (2) } },
1902 { "setImageFrameDecodingDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetImageFrameDecodingDuration), (intptr_t) (2) } },
1903 { "resetImageAnimation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResetImageAnimation), (intptr_t) (1) } },
1904 { "isImageAnimating", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsImageAnimating), (intptr_t) (1) } },
1905 { "setClearDecoderAfterAsyncFrameRequestForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting), (intptr_t) (2) } },
1906 { "imageDecodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionImageDecodeCount), (intptr_t) (1) } },
1907 { "pdfDocumentCachingCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPdfDocumentCachingCount), (intptr_t) (1) } },
1908 { "setLargeImageAsyncDecodingEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting), (intptr_t) (2) } },
1909 { "setForceUpdateImageDataEnabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting), (intptr_t) (2) } },
1910 { "setGridMaxTracksLimit", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetGridMaxTracksLimit), (intptr_t) (1) } },
1911 { "svgAnimationsInterval", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSVGAnimationsInterval), (intptr_t) (1) } },
1912 { "layerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerTreeAsText), (intptr_t) (1) } },
1913 { "layerIDForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerIDForElement), (intptr_t) (1) } },
1914 { "scrollbarOverlayStyle", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollbarOverlayStyle), (intptr_t) (0) } },
1915 { "scrollbarUsingDarkAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance), (intptr_t) (0) } },
1916 { "scrollingStateTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollingStateTreeAsText), (intptr_t) (0) } },
1917 { "mainThreadScrollingReasons", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMainThreadScrollingReasons), (intptr_t) (0) } },
1918 { "nonFastScrollableRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNonFastScrollableRects), (intptr_t) (0) } },
1919 { "repaintRectsAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRepaintRectsAsText), (intptr_t) (0) } },
1920 { "setElementUsesDisplayListDrawing", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing), (intptr_t) (2) } },
1921 { "setElementTracksDisplayListReplay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay), (intptr_t) (2) } },
1922 { "displayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDisplayListForElement), (intptr_t) (1) } },
1923 { "replayDisplayListForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReplayDisplayListForElement), (intptr_t) (1) } },
1924 { "garbageCollectDocumentResources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGarbageCollectDocumentResources), (intptr_t) (0) } },
1925 { "insertAuthorCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInsertAuthorCSS), (intptr_t) (1) } },
1926 { "insertUserCSS", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInsertUserCSS), (intptr_t) (1) } },
1927 { "beginSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure), (intptr_t) (0) } },
1928 { "endSimulatedMemoryPressure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndSimulatedMemoryPressure), (intptr_t) (0) } },
1929 { "numberOfIDBTransactions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfIDBTransactions), (intptr_t) (0) } },
1930 { "numberOfLiveNodes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfLiveNodes), (intptr_t) (0) } },
1931 { "numberOfLiveDocuments", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfLiveDocuments), (intptr_t) (0) } },
1932 { "referencingNodeCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReferencingNodeCount), (intptr_t) (1) } },
1933#if ENABLE(INTERSECTION_OBSERVER)
1934 { "numberOfIntersectionObservers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfIntersectionObservers), (intptr_t) (1) } },
1935#else
1936 { 0, 0, NoIntrinsic, { 0, 0 } },
1937#endif
1938 { "openDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionOpenDummyInspectorFrontend), (intptr_t) (1) } },
1939 { "closeDummyInspectorFrontend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCloseDummyInspectorFrontend), (intptr_t) (0) } },
1940 { "setInspectorIsUnderTest", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetInspectorIsUnderTest), (intptr_t) (1) } },
1941 { "counterValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCounterValue), (intptr_t) (1) } },
1942 { "pageNumber", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageNumber), (intptr_t) (1) } },
1943 { "shortcutIconURLs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionShortcutIconURLs), (intptr_t) (0) } },
1944 { "numberOfPages", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNumberOfPages), (intptr_t) (0) } },
1945 { "pageProperty", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageProperty), (intptr_t) (2) } },
1946 { "pageSizeAndMarginsInPixels", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels), (intptr_t) (7) } },
1947 { "setPageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageScaleFactor), (intptr_t) (3) } },
1948 { "pageScaleFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageScaleFactor), (intptr_t) (0) } },
1949 { "setPageZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageZoomFactor), (intptr_t) (1) } },
1950 { "setTextZoomFactor", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetTextZoomFactor), (intptr_t) (1) } },
1951 { "setUseFixedLayout", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUseFixedLayout), (intptr_t) (1) } },
1952 { "setFixedLayoutSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFixedLayoutSize), (intptr_t) (2) } },
1953 { "setPrinting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPrinting), (intptr_t) (2) } },
1954 { "setViewExposedRect", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetViewExposedRect), (intptr_t) (4) } },
1955 { "setHeaderHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetHeaderHeight), (intptr_t) (1) } },
1956 { "setFooterHeight", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFooterHeight), (intptr_t) (1) } },
1957 { "setTopContentInset", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetTopContentInset), (intptr_t) (1) } },
1958#if ENABLE(FULLSCREEN_API)
1959 { "webkitWillEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement), (intptr_t) (1) } },
1960#else
1961 { 0, 0, NoIntrinsic, { 0, 0 } },
1962#endif
1963#if ENABLE(FULLSCREEN_API)
1964 { "webkitDidEnterFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement), (intptr_t) (1) } },
1965#else
1966 { 0, 0, NoIntrinsic, { 0, 0 } },
1967#endif
1968#if ENABLE(FULLSCREEN_API)
1969 { "webkitWillExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement), (intptr_t) (1) } },
1970#else
1971 { 0, 0, NoIntrinsic, { 0, 0 } },
1972#endif
1973#if ENABLE(FULLSCREEN_API)
1974 { "webkitDidExitFullScreenForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement), (intptr_t) (1) } },
1975#else
1976 { 0, 0, NoIntrinsic, { 0, 0 } },
1977#endif
1978 { "setFullscreenInsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenInsets), (intptr_t) (1) } },
1979 { "setFullscreenAutoHideDuration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration), (intptr_t) (1) } },
1980 { "setFullscreenControlsHidden", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetFullscreenControlsHidden), (intptr_t) (1) } },
1981 { "setApplicationCacheOriginQuota", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota), (intptr_t) (1) } },
1982 { "registerURLSchemeAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
1983 { "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy), (intptr_t) (1) } },
1984 { "registerDefaultPortForProtocol", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol), (intptr_t) (2) } },
1985 { "mallocStatistics", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMallocStatistics), (intptr_t) (0) } },
1986 { "typeConversions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTypeConversions), (intptr_t) (0) } },
1987 { "memoryInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMemoryInfo), (intptr_t) (0) } },
1988 { "getReferencedFilePaths", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetReferencedFilePaths), (intptr_t) (0) } },
1989 { "startTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingRepaints), (intptr_t) (0) } },
1990 { "stopTrackingRepaints", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStopTrackingRepaints), (intptr_t) (0) } },
1991 { "startTrackingLayerFlushes", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingLayerFlushes), (intptr_t) (0) } },
1992 { "layerFlushCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLayerFlushCount), (intptr_t) (0) } },
1993 { "isTimerThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsTimerThrottled), (intptr_t) (1) } },
1994 { "isRequestAnimationFrameThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled), (intptr_t) (0) } },
1995 { "areTimersThrottled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAreTimersThrottled), (intptr_t) (0) } },
1996 { "setLowPowerModeEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetLowPowerModeEnabled), (intptr_t) (1) } },
1997 { "startTrackingStyleRecalcs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingStyleRecalcs), (intptr_t) (0) } },
1998 { "styleRecalcCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStyleRecalcCount), (intptr_t) (0) } },
1999 { "startTrackingCompositingUpdates", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStartTrackingCompositingUpdates), (intptr_t) (0) } },
2000 { "compositingUpdateCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCompositingUpdateCount), (intptr_t) (0) } },
2001 { "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks), (intptr_t) (0) } },
2002 { "getCurrentCursorInfo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCurrentCursorInfo), (intptr_t) (0) } },
2003 { "markerTextForListItem", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkerTextForListItem), (intptr_t) (1) } },
2004 { "toolTipFromElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionToolTipFromElement), (intptr_t) (1) } },
2005 { "deserializeBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDeserializeBuffer), (intptr_t) (1) } },
2006 { "serializeObject", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSerializeObject), (intptr_t) (1) } },
2007 { "isFromCurrentWorld", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsFromCurrentWorld), (intptr_t) (1) } },
2008 { "setUsesOverlayScrollbars", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUsesOverlayScrollbars), (intptr_t) (1) } },
2009 { "setUsesMockScrollAnimator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUsesMockScrollAnimator), (intptr_t) (1) } },
2010 { "forceReload", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionForceReload), (intptr_t) (1) } },
2011 { "reloadExpiredOnly", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReloadExpiredOnly), (intptr_t) (0) } },
2012 { "enableAutoSizeMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableAutoSizeMode), (intptr_t) (3) } },
2013#if ENABLE(VIDEO)
2014 { "mediaResponseSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaResponseSources), (intptr_t) (1) } },
2015#else
2016 { 0, 0, NoIntrinsic, { 0, 0 } },
2017#endif
2018#if ENABLE(VIDEO)
2019 { "mediaResponseContentRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaResponseContentRanges), (intptr_t) (1) } },
2020#else
2021 { 0, 0, NoIntrinsic, { 0, 0 } },
2022#endif
2023#if ENABLE(VIDEO)
2024 { "simulateAudioInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateAudioInterruption), (intptr_t) (1) } },
2025#else
2026 { 0, 0, NoIntrinsic, { 0, 0 } },
2027#endif
2028#if ENABLE(VIDEO)
2029 { "mediaElementHasCharacteristic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaElementHasCharacteristic), (intptr_t) (2) } },
2030#else
2031 { 0, 0, NoIntrinsic, { 0, 0 } },
2032#endif
2033#if ENABLE(VIDEO)
2034 { "beginSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginSimulatedHDCPError), (intptr_t) (1) } },
2035#else
2036 { 0, 0, NoIntrinsic, { 0, 0 } },
2037#endif
2038#if ENABLE(VIDEO)
2039 { "endSimulatedHDCPError", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndSimulatedHDCPError), (intptr_t) (1) } },
2040#else
2041 { 0, 0, NoIntrinsic, { 0, 0 } },
2042#endif
2043#if ENABLE(VIDEO)
2044 { "elementShouldBufferData", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementShouldBufferData), (intptr_t) (1) } },
2045#else
2046 { 0, 0, NoIntrinsic, { 0, 0 } },
2047#endif
2048#if ENABLE(VIDEO)
2049 { "elementBufferingPolicy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementBufferingPolicy), (intptr_t) (1) } },
2050#else
2051 { 0, 0, NoIntrinsic, { 0, 0 } },
2052#endif
2053#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2054 { "initializeMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInitializeMockCDM), (intptr_t) (0) } },
2055#else
2056 { 0, 0, NoIntrinsic, { 0, 0 } },
2057#endif
2058#if ENABLE(ENCRYPTED_MEDIA)
2059 { "registerMockCDM", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRegisterMockCDM), (intptr_t) (0) } },
2060#else
2061 { 0, 0, NoIntrinsic, { 0, 0 } },
2062#endif
2063 { "enableMockMediaCapabilities", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableMockMediaCapabilities), (intptr_t) (0) } },
2064#if ENABLE(SPEECH_SYNTHESIS)
2065 { "enableMockSpeechSynthesizer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer), (intptr_t) (0) } },
2066#else
2067 { 0, 0, NoIntrinsic, { 0, 0 } },
2068#endif
2069 { "getImageSourceURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetImageSourceURL), (intptr_t) (1) } },
2070#if ENABLE(VIDEO_TRACK)
2071 { "captionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCaptionsStyleSheetOverride), (intptr_t) (0) } },
2072#else
2073 { 0, 0, NoIntrinsic, { 0, 0 } },
2074#endif
2075#if ENABLE(VIDEO_TRACK)
2076 { "setCaptionsStyleSheetOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride), (intptr_t) (1) } },
2077#else
2078 { 0, 0, NoIntrinsic, { 0, 0 } },
2079#endif
2080#if ENABLE(VIDEO_TRACK)
2081 { "setPrimaryAudioTrackLanguageOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride), (intptr_t) (1) } },
2082#else
2083 { 0, 0, NoIntrinsic, { 0, 0 } },
2084#endif
2085#if ENABLE(VIDEO_TRACK)
2086 { "setCaptionDisplayMode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptionDisplayMode), (intptr_t) (1) } },
2087#else
2088 { 0, 0, NoIntrinsic, { 0, 0 } },
2089#endif
2090#if ENABLE(VIDEO_TRACK)
2091 { "createGenericCue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateGenericCue), (intptr_t) (3) } },
2092#else
2093 { 0, 0, NoIntrinsic, { 0, 0 } },
2094#endif
2095#if ENABLE(VIDEO)
2096 { "createTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateTimeRanges), (intptr_t) (2) } },
2097#else
2098 { 0, 0, NoIntrinsic, { 0, 0 } },
2099#endif
2100#if ENABLE(VIDEO)
2101 { "closestTimeToTimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClosestTimeToTimeRanges), (intptr_t) (2) } },
2102#else
2103 { 0, 0, NoIntrinsic, { 0, 0 } },
2104#endif
2105 { "isSelectPopupVisible", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSelectPopupVisible), (intptr_t) (1) } },
2106 { "isPluginUnavailabilityIndicatorObscured", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured), (intptr_t) (1) } },
2107 { "unavailablePluginReplacementText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUnavailablePluginReplacementText), (intptr_t) (1) } },
2108 { "isPluginSnapshotted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsPluginSnapshotted), (intptr_t) (1) } },
2109 { "pluginIsBelowSizeThreshold", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold), (intptr_t) (1) } },
2110 { "selectionBounds", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSelectionBounds), (intptr_t) (0) } },
2111 { "setSelectionWithoutValidation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetSelectionWithoutValidation), (intptr_t) (4) } },
2112#if ENABLE(MEDIA_SOURCE)
2113 { "initializeMockMediaSource", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInitializeMockMediaSource), (intptr_t) (0) } },
2114#else
2115 { 0, 0, NoIntrinsic, { 0, 0 } },
2116#endif
2117#if ENABLE(MEDIA_SOURCE)
2118 { "bufferedSamplesForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBufferedSamplesForTrackID), (intptr_t) (2) } },
2119#else
2120 { 0, 0, NoIntrinsic, { 0, 0 } },
2121#endif
2122#if ENABLE(MEDIA_SOURCE)
2123 { "enqueuedSamplesForTrackID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID), (intptr_t) (2) } },
2124#else
2125 { 0, 0, NoIntrinsic, { 0, 0 } },
2126#endif
2127#if ENABLE(MEDIA_SOURCE)
2128 { "setShouldGenerateTimestamps", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShouldGenerateTimestamps), (intptr_t) (2) } },
2129#else
2130 { 0, 0, NoIntrinsic, { 0, 0 } },
2131#endif
2132#if ENABLE(VIDEO)
2133 { "beginMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBeginMediaSessionInterruption), (intptr_t) (1) } },
2134#else
2135 { 0, 0, NoIntrinsic, { 0, 0 } },
2136#endif
2137#if ENABLE(VIDEO)
2138 { "endMediaSessionInterruption", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEndMediaSessionInterruption), (intptr_t) (1) } },
2139#else
2140 { 0, 0, NoIntrinsic, { 0, 0 } },
2141#endif
2142#if ENABLE(MEDIA_SESSION)
2143 { "sendMediaSessionStartOfInterruptionNotification", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification), (intptr_t) (1) } },
2144#else
2145 { 0, 0, NoIntrinsic, { 0, 0 } },
2146#endif
2147#if ENABLE(MEDIA_SESSION)
2148 { "sendMediaSessionEndOfInterruptionNotification", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification), (intptr_t) (1) } },
2149#else
2150 { 0, 0, NoIntrinsic, { 0, 0 } },
2151#endif
2152#if ENABLE(MEDIA_SESSION)
2153 { "mediaSessionCurrentState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionCurrentState), (intptr_t) (1) } },
2154#else
2155 { 0, 0, NoIntrinsic, { 0, 0 } },
2156#endif
2157#if ENABLE(MEDIA_SESSION)
2158 { "mediaElementPlayerVolume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaElementPlayerVolume), (intptr_t) (1) } },
2159#else
2160 { 0, 0, NoIntrinsic, { 0, 0 } },
2161#endif
2162#if ENABLE(MEDIA_SESSION)
2163 { "sendMediaControlEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSendMediaControlEvent), (intptr_t) (1) } },
2164#else
2165 { 0, 0, NoIntrinsic, { 0, 0 } },
2166#endif
2167#if ENABLE(VIDEO)
2168 { "applicationWillBecomeInactive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationWillBecomeInactive), (intptr_t) (0) } },
2169#else
2170 { 0, 0, NoIntrinsic, { 0, 0 } },
2171#endif
2172#if ENABLE(VIDEO)
2173 { "applicationDidBecomeActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationDidBecomeActive), (intptr_t) (0) } },
2174#else
2175 { 0, 0, NoIntrinsic, { 0, 0 } },
2176#endif
2177#if ENABLE(VIDEO)
2178 { "applicationWillEnterForeground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationWillEnterForeground), (intptr_t) (0) } },
2179#else
2180 { 0, 0, NoIntrinsic, { 0, 0 } },
2181#endif
2182#if ENABLE(VIDEO)
2183 { "applicationDidEnterBackground", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplicationDidEnterBackground), (intptr_t) (0) } },
2184#else
2185 { 0, 0, NoIntrinsic, { 0, 0 } },
2186#endif
2187#if ENABLE(VIDEO)
2188 { "setMediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaSessionRestrictions), (intptr_t) (2) } },
2189#else
2190 { 0, 0, NoIntrinsic, { 0, 0 } },
2191#endif
2192#if ENABLE(VIDEO)
2193 { "mediaSessionRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionRestrictions), (intptr_t) (1) } },
2194#else
2195 { 0, 0, NoIntrinsic, { 0, 0 } },
2196#endif
2197#if ENABLE(VIDEO)
2198 { "setMediaElementRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaElementRestrictions), (intptr_t) (2) } },
2199#else
2200 { 0, 0, NoIntrinsic, { 0, 0 } },
2201#endif
2202#if ENABLE(WEB_AUDIO)
2203 { "setAudioContextRestrictions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAudioContextRestrictions), (intptr_t) (2) } },
2204#else
2205 { 0, 0, NoIntrinsic, { 0, 0 } },
2206#endif
2207#if ENABLE(VIDEO)
2208 { "postRemoteControlCommand", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPostRemoteControlCommand), (intptr_t) (1) } },
2209#else
2210 { 0, 0, NoIntrinsic, { 0, 0 } },
2211#endif
2212#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2213 { "setMockMediaPlaybackTargetPickerEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled), (intptr_t) (1) } },
2214#else
2215 { 0, 0, NoIntrinsic, { 0, 0 } },
2216#endif
2217#if ENABLE(WIRELESS_PLAYBACK_TARGET)
2218 { "setMockMediaPlaybackTargetPickerState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState), (intptr_t) (2) } },
2219#else
2220 { 0, 0, NoIntrinsic, { 0, 0 } },
2221#endif
2222#if ENABLE(MEDIA_STREAM)
2223 { "setMockMediaCaptureDevicesEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled), (intptr_t) (1) } },
2224#else
2225 { 0, 0, NoIntrinsic, { 0, 0 } },
2226#endif
2227#if ENABLE(MEDIA_STREAM)
2228 { "setCustomPrivateRecorderCreator", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator), (intptr_t) (0) } },
2229#else
2230 { 0, 0, NoIntrinsic, { 0, 0 } },
2231#endif
2232#if ENABLE(WEB_RTC)
2233 { "emulateRTCPeerConnectionPlatformEvent", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent), (intptr_t) (2) } },
2234#else
2235 { 0, 0, NoIntrinsic, { 0, 0 } },
2236#endif
2237#if ENABLE(WEB_RTC)
2238 { "useMockRTCPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory), (intptr_t) (1) } },
2239#else
2240 { 0, 0, NoIntrinsic, { 0, 0 } },
2241#endif
2242#if ENABLE(WEB_RTC)
2243 { "setICECandidateFiltering", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetICECandidateFiltering), (intptr_t) (1) } },
2244#else
2245 { 0, 0, NoIntrinsic, { 0, 0 } },
2246#endif
2247#if ENABLE(WEB_RTC)
2248 { "setEnumeratingAllNetworkInterfacesEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled), (intptr_t) (1) } },
2249#else
2250 { 0, 0, NoIntrinsic, { 0, 0 } },
2251#endif
2252#if ENABLE(WEB_RTC)
2253 { "stopPeerConnection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionStopPeerConnection), (intptr_t) (1) } },
2254#else
2255 { 0, 0, NoIntrinsic, { 0, 0 } },
2256#endif
2257#if ENABLE(WEB_RTC)
2258 { "clearPeerConnectionFactory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearPeerConnectionFactory), (intptr_t) (0) } },
2259#else
2260 { 0, 0, NoIntrinsic, { 0, 0 } },
2261#endif
2262#if ENABLE(VIDEO)
2263 { "simulateSystemSleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateSystemSleep), (intptr_t) (0) } },
2264#else
2265 { 0, 0, NoIntrinsic, { 0, 0 } },
2266#endif
2267#if ENABLE(VIDEO)
2268 { "simulateSystemWake", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateSystemWake), (intptr_t) (0) } },
2269#else
2270 { 0, 0, NoIntrinsic, { 0, 0 } },
2271#endif
2272#if ENABLE(VIDEO)
2273 { "elementIsBlockingDisplaySleep", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep), (intptr_t) (1) } },
2274#else
2275 { 0, 0, NoIntrinsic, { 0, 0 } },
2276#endif
2277 { "installMockPageOverlay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionInstallMockPageOverlay), (intptr_t) (1) } },
2278 { "pageOverlayLayerTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText), (intptr_t) (0) } },
2279 { "setPageMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageMuted), (intptr_t) (1) } },
2280 { "pageMediaState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageMediaState), (intptr_t) (0) } },
2281 { "setPageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageDefersLoading), (intptr_t) (1) } },
2282 { "pageDefersLoading", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageDefersLoading), (intptr_t) (0) } },
2283 { "createFile", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCreateFile), (intptr_t) (1) } },
2284 { "queueMicroTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionQueueMicroTask), (intptr_t) (1) } },
2285 { "testPreloaderSettingViewport", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTestPreloaderSettingViewport), (intptr_t) (0) } },
2286#if ENABLE(CSS_SCROLL_SNAP)
2287 { "scrollSnapOffsets", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionScrollSnapOffsets), (intptr_t) (1) } },
2288#else
2289 { 0, 0, NoIntrinsic, { 0, 0 } },
2290#endif
2291#if ENABLE(CSS_SCROLL_SNAP)
2292 { "setPlatformMomentumScrollingPredictionEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled), (intptr_t) (1) } },
2293#else
2294 { 0, 0, NoIntrinsic, { 0, 0 } },
2295#endif
2296 { "pathStringWithShrinkWrappedRects", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects), (intptr_t) (2) } },
2297#if ENABLE(VIDEO)
2298 { "getCurrentMediaControlsStatusForElement", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement), (intptr_t) (1) } },
2299#else
2300 { 0, 0, NoIntrinsic, { 0, 0 } },
2301#endif
2302 { "userVisibleString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserVisibleString), (intptr_t) (1) } },
2303 { "setShowAllPlugins", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetShowAllPlugins), (intptr_t) (1) } },
2304#if ENABLE(STREAMS_API)
2305 { "cloneArrayBuffer", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCloneArrayBuffer), (intptr_t) (3) } },
2306#else
2307 { 0, 0, NoIntrinsic, { 0, 0 } },
2308#endif
2309#if ENABLE(STREAMS_API)
2310 { "isReadableStreamDisturbed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsReadableStreamDisturbed), (intptr_t) (1) } },
2311#else
2312 { 0, 0, NoIntrinsic, { 0, 0 } },
2313#endif
2314 { "resourceLoadStatisticsForURL", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResourceLoadStatisticsForURL), (intptr_t) (1) } },
2315 { "setResourceLoadStatisticsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled), (intptr_t) (1) } },
2316 { "setCanShowModalDialogOverride", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCanShowModalDialogOverride), (intptr_t) (1) } },
2317 { "composedTreeAsText", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionComposedTreeAsText), (intptr_t) (1) } },
2318 { "isProcessingUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsProcessingUserGesture), (intptr_t) (0) } },
2319 { "lastHandledUserGestureTimestamp", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp), (intptr_t) (0) } },
2320 { "withUserGesture", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionWithUserGesture), (intptr_t) (1) } },
2321 { "userIsInteracting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserIsInteracting), (intptr_t) (0) } },
2322 { "observeGC", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionObserveGC), (intptr_t) (1) } },
2323 { "setUserInterfaceLayoutDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection), (intptr_t) (1) } },
2324 { "setBaseWritingDirection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetBaseWritingDirection), (intptr_t) (1) } },
2325 { "userPrefersReducedMotion", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUserPrefersReducedMotion), (intptr_t) (0) } },
2326 { "reportBacktrace", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReportBacktrace), (intptr_t) (0) } },
2327#if ENABLE(POINTER_LOCK)
2328 { "pageHasPendingPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageHasPendingPointerLock), (intptr_t) (0) } },
2329#else
2330 { 0, 0, NoIntrinsic, { 0, 0 } },
2331#endif
2332#if ENABLE(POINTER_LOCK)
2333 { "pageHasPointerLock", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPageHasPointerLock), (intptr_t) (0) } },
2334#else
2335 { 0, 0, NoIntrinsic, { 0, 0 } },
2336#endif
2337 { "accessKeyModifiers", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAccessKeyModifiers), (intptr_t) (0) } },
2338 { "setQuickLookPassword", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetQuickLookPassword), (intptr_t) (1) } },
2339 { "setAsRunningUserScripts", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAsRunningUserScripts), (intptr_t) (0) } },
2340#if ENABLE(APPLE_PAY)
2341 { "setHasStartedApplePaySession", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetHasStartedApplePaySession), (intptr_t) (0) } },
2342#else
2343 { 0, 0, NoIntrinsic, { 0, 0 } },
2344#endif
2345 { "disableTileSizeUpdateDelay", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay), (intptr_t) (0) } },
2346 { "setSpeculativeTilingDelayDisabledForTesting", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting), (intptr_t) (1) } },
2347#if ENABLE(WEBGL)
2348 { "simulateWebGLContextChanged", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateWebGLContextChanged), (intptr_t) (1) } },
2349#else
2350 { 0, 0, NoIntrinsic, { 0, 0 } },
2351#endif
2352#if ENABLE(WEBGL)
2353 { "failNextGPUStatusCheck", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionFailNextGPUStatusCheck), (intptr_t) (1) } },
2354#else
2355 { 0, 0, NoIntrinsic, { 0, 0 } },
2356#endif
2357#if ENABLE(WEBGL)
2358 { "hasLowAndHighPowerGPUs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs), (intptr_t) (0) } },
2359#else
2360 { 0, 0, NoIntrinsic, { 0, 0 } },
2361#endif
2362 { "setPageVisibility", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageVisibility), (intptr_t) (1) } },
2363 { "setPageIsFocusedAndActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetPageIsFocusedAndActive), (intptr_t) (1) } },
2364#if ENABLE(WEB_RTC)
2365 { "setH264HardwareEncoderAllowed", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed), (intptr_t) (1) } },
2366#else
2367 { 0, 0, NoIntrinsic, { 0, 0 } },
2368#endif
2369#if ENABLE(WEB_RTC)
2370 { "applyRotationForOutgoingVideoSources", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources), (intptr_t) (1) } },
2371#else
2372 { 0, 0, NoIntrinsic, { 0, 0 } },
2373#endif
2374#if ENABLE(MEDIA_STREAM)
2375 { "setCameraMediaStreamTrackOrientation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation), (intptr_t) (2) } },
2376#else
2377 { 0, 0, NoIntrinsic, { 0, 0 } },
2378#endif
2379#if ENABLE(MEDIA_STREAM)
2380 { "observeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionObserveMediaStreamTrack), (intptr_t) (1) } },
2381#else
2382 { 0, 0, NoIntrinsic, { 0, 0 } },
2383#endif
2384#if ENABLE(MEDIA_STREAM)
2385 { "grabNextMediaStreamTrackFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame), (intptr_t) (0) } },
2386#else
2387 { 0, 0, NoIntrinsic, { 0, 0 } },
2388#endif
2389#if ENABLE(MEDIA_STREAM)
2390 { "delayMediaStreamTrackSamples", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples), (intptr_t) (2) } },
2391#else
2392 { 0, 0, NoIntrinsic, { 0, 0 } },
2393#endif
2394#if ENABLE(MEDIA_STREAM)
2395 { "setMediaStreamTrackMuted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamTrackMuted), (intptr_t) (2) } },
2396#else
2397 { 0, 0, NoIntrinsic, { 0, 0 } },
2398#endif
2399#if ENABLE(MEDIA_STREAM)
2400 { "removeMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionRemoveMediaStreamTrack), (intptr_t) (2) } },
2401#else
2402 { 0, 0, NoIntrinsic, { 0, 0 } },
2403#endif
2404#if ENABLE(MEDIA_STREAM)
2405 { "simulateMediaStreamTrackCaptureSourceFailure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure), (intptr_t) (1) } },
2406#else
2407 { 0, 0, NoIntrinsic, { 0, 0 } },
2408#endif
2409#if ENABLE(MEDIA_STREAM)
2410 { "setMediaStreamTrackIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier), (intptr_t) (2) } },
2411#else
2412 { 0, 0, NoIntrinsic, { 0, 0 } },
2413#endif
2414#if ENABLE(MEDIA_STREAM)
2415 { "setMediaStreamSourceInterrupted", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted), (intptr_t) (2) } },
2416#else
2417 { 0, 0, NoIntrinsic, { 0, 0 } },
2418#endif
2419#if ENABLE(MEDIA_STREAM)
2420 { "setDisableGetDisplayMediaUserGestureConstraint", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint), (intptr_t) (1) } },
2421#else
2422 { 0, 0, NoIntrinsic, { 0, 0 } },
2423#endif
2424 { "documentIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionDocumentIdentifier), (intptr_t) (1) } },
2425 { "isDocumentAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsDocumentAlive), (intptr_t) (1) } },
2426 { "isAnyWorkletGlobalScopeAlive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive), (intptr_t) (0) } },
2427 { "serviceWorkerClientIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionServiceWorkerClientIdentifier), (intptr_t) (1) } },
2428 { "clearCacheStorageMemoryRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation), (intptr_t) (0) } },
2429 { "cacheStorageEngineRepresentation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCacheStorageEngineRepresentation), (intptr_t) (0) } },
2430 { "setResponseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetResponseSizeWithPadding), (intptr_t) (2) } },
2431 { "responseSizeWithPadding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionResponseSizeWithPadding), (intptr_t) (1) } },
2432 { "updateQuotaBasedOnSpaceUsage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage), (intptr_t) (0) } },
2433 { "setConsoleMessageListener", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetConsoleMessageListener), (intptr_t) (1) } },
2434 { "audioSessionCategory", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAudioSessionCategory), (intptr_t) (0) } },
2435 { "preferredAudioBufferSize", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPreferredAudioBufferSize), (intptr_t) (0) } },
2436 { "audioSessionActive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionAudioSessionActive), (intptr_t) (0) } },
2437#if ENABLE(SERVICE_WORKER)
2438 { "hasServiceWorkerRegistration", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasServiceWorkerRegistration), (intptr_t) (1) } },
2439#else
2440 { 0, 0, NoIntrinsic, { 0, 0 } },
2441#endif
2442#if ENABLE(SERVICE_WORKER)
2443 { "terminateServiceWorker", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTerminateServiceWorker), (intptr_t) (1) } },
2444#else
2445 { 0, 0, NoIntrinsic, { 0, 0 } },
2446#endif
2447#if ENABLE(SERVICE_WORKER)
2448 { "hasServiceWorkerConnection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionHasServiceWorkerConnection), (intptr_t) (0) } },
2449#else
2450 { 0, 0, NoIntrinsic, { 0, 0 } },
2451#endif
2452 { "isSystemPreviewLink", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSystemPreviewLink), (intptr_t) (1) } },
2453 { "isSystemPreviewImage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionIsSystemPreviewImage), (intptr_t) (1) } },
2454 { "usingAppleInternalSDK", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionUsingAppleInternalSDK), (intptr_t) (0) } },
2455 { "postTask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPostTask), (intptr_t) (1) } },
2456 { "markContextAsInsecure", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMarkContextAsInsecure), (intptr_t) (0) } },
2457#if ENABLE(VIDEO)
2458 { "bestMediaElementForShowingPlaybackControlsManager", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager), (intptr_t) (1) } },
2459#else
2460 { 0, 0, NoIntrinsic, { 0, 0 } },
2461#endif
2462#if ENABLE(VIDEO)
2463 { "mediaSessionState", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionMediaSessionState), (intptr_t) (1) } },
2464#else
2465 { 0, 0, NoIntrinsic, { 0, 0 } },
2466#endif
2467 { "ongoingLoadsDescriptions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionOngoingLoadsDescriptions), (intptr_t) (0) } },
2468 { "setCaptureExtraNetworkLoadMetricsEnabled", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled), (intptr_t) (1) } },
2469 { "reloadWithoutContentExtensions", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionReloadWithoutContentExtensions), (intptr_t) (0) } },
2470 { "setUseSystemAppearance", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetUseSystemAppearance), (intptr_t) (1) } },
2471 { "pluginCount", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPluginCount), (intptr_t) (0) } },
2472 { "notifyResourceLoadObserver", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionNotifyResourceLoadObserver), (intptr_t) (0) } },
2473 { "primaryScreenDisplayID", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionPrimaryScreenDisplayID), (intptr_t) (0) } },
2474 { "capsLockIsOn", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionCapsLockIsOn), (intptr_t) (0) } },
2475 { "supportsVCPEncoder", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSupportsVCPEncoder), (intptr_t) (0) } },
2476 { "parseHEVCCodecParameters", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionParseHEVCCodecParameters), (intptr_t) (1) } },
2477 { "getCookies", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionGetCookies), (intptr_t) (0) } },
2478 { "setAlwaysAllowLocalWebarchive", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive), (intptr_t) (1) } },
2479 { "processWillSuspend", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionProcessWillSuspend), (intptr_t) (0) } },
2480 { "processDidResume", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionProcessDidResume), (intptr_t) (0) } },
2481 { "testDictionaryLogging", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionTestDictionaryLogging), (intptr_t) (0) } },
2482 { "setXHRMaximumIntervalForUserGestureForwarding", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding), (intptr_t) (2) } },
2483 { "LAYER_TREE_INCLUDES_VISIBLE_RECTS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
2484 { "LAYER_TREE_INCLUDES_TILE_CACHES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(2) } },
2485 { "LAYER_TREE_INCLUDES_REPAINT_RECTS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(4) } },
2486 { "LAYER_TREE_INCLUDES_PAINTING_PHASES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(8) } },
2487 { "LAYER_TREE_INCLUDES_CONTENT_LAYERS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(16) } },
2488 { "LAYER_TREE_INCLUDES_ACCELERATES_DRAWING", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(32) } },
2489 { "LAYER_TREE_INCLUDES_BACKING_STORE_ATTACHED", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(64) } },
2490 { "LAYER_TREE_INCLUDES_ROOT_LAYER_PROPERTIES", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(128) } },
2491 { "LAYER_TREE_INCLUDES_EVENT_REGION", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(256) } },
2492 { "DISPLAY_LIST_INCLUDES_PLATFORM_OPERATIONS", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::ConstantInteger, NoIntrinsic, { (long long)(1) } },
2493};
2494
2495const ClassInfo JSInternalsPrototype::s_info = { "InternalsPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSInternalsPrototype) };
2496
2497void JSInternalsPrototype::finishCreation(VM& vm)
2498{
2499 Base::finishCreation(vm);
2500 reifyStaticProperties(vm, JSInternals::info(), JSInternalsPrototypeTableValues, *this);
2501}
2502
2503const ClassInfo JSInternals::s_info = { "Internals", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSInternals) };
2504
2505JSInternals::JSInternals(Structure* structure, JSDOMGlobalObject& globalObject, Ref<Internals>&& impl)
2506 : JSDOMWrapper<Internals>(structure, globalObject, WTFMove(impl))
2507{
2508}
2509
2510void JSInternals::finishCreation(VM& vm)
2511{
2512 Base::finishCreation(vm);
2513 ASSERT(inherits(vm, info()));
2514
2515}
2516
2517JSObject* JSInternals::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
2518{
2519 return JSInternalsPrototype::create(vm, &globalObject, JSInternalsPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
2520}
2521
2522JSObject* JSInternals::prototype(VM& vm, JSDOMGlobalObject& globalObject)
2523{
2524 return getDOMPrototype<JSInternals>(vm, globalObject);
2525}
2526
2527void JSInternals::destroy(JSC::JSCell* cell)
2528{
2529 JSInternals* thisObject = static_cast<JSInternals*>(cell);
2530 thisObject->JSInternals::~JSInternals();
2531}
2532
2533template<> inline JSInternals* IDLAttribute<JSInternals>::cast(ExecState& state, EncodedJSValue thisValue)
2534{
2535 return jsDynamicCast<JSInternals*>(state.vm(), JSValue::decode(thisValue));
2536}
2537
2538template<> inline JSInternals* IDLOperation<JSInternals>::cast(ExecState& state)
2539{
2540 return jsDynamicCast<JSInternals*>(state.vm(), state.thisValue());
2541}
2542
2543static inline JSValue jsInternalsAnimationsIntervalGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2544{
2545 UNUSED_PARAM(throwScope);
2546 UNUSED_PARAM(state);
2547 auto& impl = thisObject.wrapped();
2548 JSValue result = toJS<IDLDouble>(state, throwScope, impl.animationsInterval());
2549 return result;
2550}
2551
2552EncodedJSValue jsInternalsAnimationsInterval(ExecState* state, EncodedJSValue thisValue, PropertyName)
2553{
2554 return IDLAttribute<JSInternals>::get<jsInternalsAnimationsIntervalGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "animationsInterval");
2555}
2556
2557static inline JSValue jsInternalsSentenceRetroCorrectionEnabledGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2558{
2559 UNUSED_PARAM(throwScope);
2560 UNUSED_PARAM(state);
2561 auto& impl = thisObject.wrapped();
2562 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.sentenceRetroCorrectionEnabled());
2563 return result;
2564}
2565
2566EncodedJSValue jsInternalsSentenceRetroCorrectionEnabled(ExecState* state, EncodedJSValue thisValue, PropertyName)
2567{
2568 return IDLAttribute<JSInternals>::get<jsInternalsSentenceRetroCorrectionEnabledGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "sentenceRetroCorrectionEnabled");
2569}
2570
2571static inline JSValue jsInternalsSettingsGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2572{
2573 UNUSED_PARAM(throwScope);
2574 UNUSED_PARAM(state);
2575 auto& impl = thisObject.wrapped();
2576 JSValue result = toJS<IDLInterface<InternalSettings>>(state, *thisObject.globalObject(), throwScope, impl.settings());
2577 return result;
2578}
2579
2580EncodedJSValue jsInternalsSettings(ExecState* state, EncodedJSValue thisValue, PropertyName)
2581{
2582 return IDLAttribute<JSInternals>::get<jsInternalsSettingsGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "settings");
2583}
2584
2585static inline JSValue jsInternalsWorkerThreadCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2586{
2587 UNUSED_PARAM(throwScope);
2588 UNUSED_PARAM(state);
2589 auto& impl = thisObject.wrapped();
2590 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.workerThreadCount());
2591 return result;
2592}
2593
2594EncodedJSValue jsInternalsWorkerThreadCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2595{
2596 return IDLAttribute<JSInternals>::get<jsInternalsWorkerThreadCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "workerThreadCount");
2597}
2598
2599static inline JSValue jsInternalsAreSVGAnimationsPausedGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2600{
2601 UNUSED_PARAM(throwScope);
2602 UNUSED_PARAM(state);
2603 auto& impl = thisObject.wrapped();
2604 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.areSVGAnimationsPaused());
2605 return result;
2606}
2607
2608EncodedJSValue jsInternalsAreSVGAnimationsPaused(ExecState* state, EncodedJSValue thisValue, PropertyName)
2609{
2610 return IDLAttribute<JSInternals>::get<jsInternalsAreSVGAnimationsPausedGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "areSVGAnimationsPaused");
2611}
2612
2613static inline JSValue jsInternalsIsUnderMemoryPressureGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2614{
2615 UNUSED_PARAM(throwScope);
2616 UNUSED_PARAM(state);
2617 auto& impl = thisObject.wrapped();
2618 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.isUnderMemoryPressure());
2619 return result;
2620}
2621
2622EncodedJSValue jsInternalsIsUnderMemoryPressure(ExecState* state, EncodedJSValue thisValue, PropertyName)
2623{
2624 return IDLAttribute<JSInternals>::get<jsInternalsIsUnderMemoryPressureGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "isUnderMemoryPressure");
2625}
2626
2627#if ENABLE(FULLSCREEN_API)
2628static inline JSValue jsInternalsIsAnimatingFullScreenGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2629{
2630 UNUSED_PARAM(throwScope);
2631 UNUSED_PARAM(state);
2632 auto& impl = thisObject.wrapped();
2633 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.isAnimatingFullScreen());
2634 return result;
2635}
2636
2637EncodedJSValue jsInternalsIsAnimatingFullScreen(ExecState* state, EncodedJSValue thisValue, PropertyName)
2638{
2639 return IDLAttribute<JSInternals>::get<jsInternalsIsAnimatingFullScreenGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "isAnimatingFullScreen");
2640}
2641
2642#endif
2643
2644static inline JSValue jsInternalsRequestAnimationFrameIntervalGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2645{
2646 UNUSED_PARAM(throwScope);
2647 UNUSED_PARAM(state);
2648 auto& impl = thisObject.wrapped();
2649 JSValue result = toJS<IDLDouble>(state, throwScope, impl.requestAnimationFrameInterval());
2650 return result;
2651}
2652
2653EncodedJSValue jsInternalsRequestAnimationFrameInterval(ExecState* state, EncodedJSValue thisValue, PropertyName)
2654{
2655 return IDLAttribute<JSInternals>::get<jsInternalsRequestAnimationFrameIntervalGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "requestAnimationFrameInterval");
2656}
2657
2658static inline JSValue jsInternalsScriptedAnimationsAreSuspendedGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2659{
2660 UNUSED_PARAM(throwScope);
2661 UNUSED_PARAM(state);
2662 auto& impl = thisObject.wrapped();
2663 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.scriptedAnimationsAreSuspended());
2664 return result;
2665}
2666
2667EncodedJSValue jsInternalsScriptedAnimationsAreSuspended(ExecState* state, EncodedJSValue thisValue, PropertyName)
2668{
2669 return IDLAttribute<JSInternals>::get<jsInternalsScriptedAnimationsAreSuspendedGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "scriptedAnimationsAreSuspended");
2670}
2671
2672static inline JSValue jsInternalsEventThrottlingBehaviorOverrideGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2673{
2674 UNUSED_PARAM(throwScope);
2675 UNUSED_PARAM(state);
2676 auto& impl = thisObject.wrapped();
2677 JSValue result = toJS<IDLNullable<IDLEnumeration<Internals::EventThrottlingBehavior>>>(state, throwScope, impl.eventThrottlingBehaviorOverride());
2678 return result;
2679}
2680
2681EncodedJSValue jsInternalsEventThrottlingBehaviorOverride(ExecState* state, EncodedJSValue thisValue, PropertyName)
2682{
2683 return IDLAttribute<JSInternals>::get<jsInternalsEventThrottlingBehaviorOverrideGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "eventThrottlingBehaviorOverride");
2684}
2685
2686static inline bool setJSInternalsEventThrottlingBehaviorOverrideSetter(ExecState& state, JSInternals& thisObject, JSValue value, ThrowScope& throwScope)
2687{
2688 UNUSED_PARAM(throwScope);
2689 auto& impl = thisObject.wrapped();
2690 auto optionalNativeValue = parseEnumeration<Internals::EventThrottlingBehavior>(state, value);
2691 RETURN_IF_EXCEPTION(throwScope, false);
2692 if (UNLIKELY(!optionalNativeValue))
2693 return false;
2694 auto nativeValue = optionalNativeValue.value();
2695 AttributeSetter::call(state, throwScope, [&] {
2696 return impl.setEventThrottlingBehaviorOverride(WTFMove(nativeValue));
2697 });
2698 return true;
2699}
2700
2701bool setJSInternalsEventThrottlingBehaviorOverride(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2702{
2703 return IDLAttribute<JSInternals>::set<setJSInternalsEventThrottlingBehaviorOverrideSetter>(*state, thisValue, encodedValue, "eventThrottlingBehaviorOverride");
2704}
2705
2706static inline JSValue jsInternalsLastStyleUpdateSizeGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2707{
2708 UNUSED_PARAM(throwScope);
2709 UNUSED_PARAM(state);
2710 auto& impl = thisObject.wrapped();
2711 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.lastStyleUpdateSize());
2712 return result;
2713}
2714
2715EncodedJSValue jsInternalsLastStyleUpdateSize(ExecState* state, EncodedJSValue thisValue, PropertyName)
2716{
2717 return IDLAttribute<JSInternals>::get<jsInternalsLastStyleUpdateSizeGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "lastStyleUpdateSize");
2718}
2719
2720static inline JSValue jsInternalsCompositingPolicyOverrideGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2721{
2722 UNUSED_PARAM(throwScope);
2723 UNUSED_PARAM(state);
2724 auto& impl = thisObject.wrapped();
2725 JSValue result = toJS<IDLNullable<IDLEnumeration<Internals::CompositingPolicy>>>(state, throwScope, impl.compositingPolicyOverride());
2726 return result;
2727}
2728
2729EncodedJSValue jsInternalsCompositingPolicyOverride(ExecState* state, EncodedJSValue thisValue, PropertyName)
2730{
2731 return IDLAttribute<JSInternals>::get<jsInternalsCompositingPolicyOverrideGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "compositingPolicyOverride");
2732}
2733
2734static inline bool setJSInternalsCompositingPolicyOverrideSetter(ExecState& state, JSInternals& thisObject, JSValue value, ThrowScope& throwScope)
2735{
2736 UNUSED_PARAM(throwScope);
2737 auto& impl = thisObject.wrapped();
2738 auto optionalNativeValue = parseEnumeration<Internals::CompositingPolicy>(state, value);
2739 RETURN_IF_EXCEPTION(throwScope, false);
2740 if (UNLIKELY(!optionalNativeValue))
2741 return false;
2742 auto nativeValue = optionalNativeValue.value();
2743 AttributeSetter::call(state, throwScope, [&] {
2744 return impl.setCompositingPolicyOverride(WTFMove(nativeValue));
2745 });
2746 return true;
2747}
2748
2749bool setJSInternalsCompositingPolicyOverride(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2750{
2751 return IDLAttribute<JSInternals>::set<setJSInternalsCompositingPolicyOverrideSetter>(*state, thisValue, encodedValue, "compositingPolicyOverride");
2752}
2753
2754static inline JSValue jsInternalsLayoutCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2755{
2756 UNUSED_PARAM(throwScope);
2757 UNUSED_PARAM(state);
2758 auto& impl = thisObject.wrapped();
2759 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.layoutCount());
2760 return result;
2761}
2762
2763EncodedJSValue jsInternalsLayoutCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2764{
2765 return IDLAttribute<JSInternals>::get<jsInternalsLayoutCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "layoutCount");
2766}
2767
2768#if ENABLE(CONTENT_FILTERING)
2769static inline JSValue jsInternalsMockContentFilterSettingsGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2770{
2771 UNUSED_PARAM(throwScope);
2772 UNUSED_PARAM(state);
2773 auto& impl = thisObject.wrapped();
2774 JSValue result = toJS<IDLInterface<MockContentFilterSettings>>(state, *thisObject.globalObject(), throwScope, impl.mockContentFilterSettings());
2775 return result;
2776}
2777
2778EncodedJSValue jsInternalsMockContentFilterSettings(ExecState* state, EncodedJSValue thisValue, PropertyName)
2779{
2780 return IDLAttribute<JSInternals>::get<jsInternalsMockContentFilterSettingsGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "mockContentFilterSettings");
2781}
2782
2783#endif
2784
2785#if ENABLE(MEDIA_STREAM)
2786static inline JSValue jsInternalsTrackAudioSampleCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2787{
2788 UNUSED_PARAM(throwScope);
2789 UNUSED_PARAM(state);
2790 auto& impl = thisObject.wrapped();
2791 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.trackAudioSampleCount());
2792 return result;
2793}
2794
2795EncodedJSValue jsInternalsTrackAudioSampleCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2796{
2797 return IDLAttribute<JSInternals>::get<jsInternalsTrackAudioSampleCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "trackAudioSampleCount");
2798}
2799
2800#endif
2801
2802#if ENABLE(MEDIA_STREAM)
2803static inline JSValue jsInternalsTrackVideoSampleCountGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2804{
2805 UNUSED_PARAM(throwScope);
2806 UNUSED_PARAM(state);
2807 auto& impl = thisObject.wrapped();
2808 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.trackVideoSampleCount());
2809 return result;
2810}
2811
2812EncodedJSValue jsInternalsTrackVideoSampleCount(ExecState* state, EncodedJSValue thisValue, PropertyName)
2813{
2814 return IDLAttribute<JSInternals>::get<jsInternalsTrackVideoSampleCountGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "trackVideoSampleCount");
2815}
2816
2817#endif
2818
2819#if ENABLE(APPLE_PAY)
2820static inline JSValue jsInternalsMockPaymentCoordinatorGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2821{
2822 UNUSED_PARAM(throwScope);
2823 UNUSED_PARAM(state);
2824 auto* context = jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject())->scriptExecutionContext();
2825 if (UNLIKELY(!context))
2826 return jsUndefined();
2827 ASSERT(context->isDocument());
2828 auto& document = downcast<Document>(*context);
2829 auto& impl = thisObject.wrapped();
2830 JSValue result = toJS<IDLInterface<MockPaymentCoordinator>>(state, *thisObject.globalObject(), throwScope, impl.mockPaymentCoordinator(document));
2831 return result;
2832}
2833
2834EncodedJSValue jsInternalsMockPaymentCoordinator(ExecState* state, EncodedJSValue thisValue, PropertyName)
2835{
2836 return IDLAttribute<JSInternals>::get<jsInternalsMockPaymentCoordinatorGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "mockPaymentCoordinator");
2837}
2838
2839#endif
2840
2841#if ENABLE(VIDEO)
2842static inline JSValue jsInternalsNowPlayingStateGetter(ExecState& state, JSInternals& thisObject, ThrowScope& throwScope)
2843{
2844 UNUSED_PARAM(throwScope);
2845 UNUSED_PARAM(state);
2846 auto& impl = thisObject.wrapped();
2847 JSValue result = toJS<IDLDictionary<Internals::NowPlayingState>>(state, *thisObject.globalObject(), throwScope, impl.nowPlayingState());
2848 return result;
2849}
2850
2851EncodedJSValue jsInternalsNowPlayingState(ExecState* state, EncodedJSValue thisValue, PropertyName)
2852{
2853 return IDLAttribute<JSInternals>::get<jsInternalsNowPlayingStateGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "nowPlayingState");
2854}
2855
2856#endif
2857
2858static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAddressBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2859{
2860 UNUSED_PARAM(state);
2861 UNUSED_PARAM(throwScope);
2862 auto& impl = castedThis->wrapped();
2863 if (UNLIKELY(state->argumentCount() < 1))
2864 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2865 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "address", "Node"); });
2866 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2867 return JSValue::encode(toJS<IDLDOMString>(*state, impl.address(*node)));
2868}
2869
2870EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddress(ExecState* state)
2871{
2872 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAddressBody>(*state, "address");
2873}
2874
2875static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNodeNeedsStyleRecalcBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2876{
2877 UNUSED_PARAM(state);
2878 UNUSED_PARAM(throwScope);
2879 auto& impl = castedThis->wrapped();
2880 if (UNLIKELY(state->argumentCount() < 1))
2881 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2882 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "nodeNeedsStyleRecalc", "Node"); });
2883 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2884 return JSValue::encode(toJS<IDLBoolean>(impl.nodeNeedsStyleRecalc(*node)));
2885}
2886
2887EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodeNeedsStyleRecalc(ExecState* state)
2888{
2889 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNodeNeedsStyleRecalcBody>(*state, "nodeNeedsStyleRecalc");
2890}
2891
2892static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStyleChangeTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2893{
2894 UNUSED_PARAM(state);
2895 UNUSED_PARAM(throwScope);
2896 auto& impl = castedThis->wrapped();
2897 if (UNLIKELY(state->argumentCount() < 1))
2898 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2899 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "styleChangeType", "Node"); });
2900 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2901 return JSValue::encode(toJS<IDLDOMString>(*state, impl.styleChangeType(*node)));
2902}
2903
2904EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleChangeType(ExecState* state)
2905{
2906 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStyleChangeTypeBody>(*state, "styleChangeType");
2907}
2908
2909static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDescriptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2910{
2911 UNUSED_PARAM(state);
2912 UNUSED_PARAM(throwScope);
2913 auto& impl = castedThis->wrapped();
2914 if (UNLIKELY(state->argumentCount() < 1))
2915 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2916 auto value = convert<IDLAny>(*state, state->uncheckedArgument(0));
2917 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2918 return JSValue::encode(toJS<IDLDOMString>(*state, impl.description(WTFMove(value))));
2919}
2920
2921EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDescription(ExecState* state)
2922{
2923 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDescriptionBody>(*state, "description");
2924}
2925
2926static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasPausedImageAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2927{
2928 UNUSED_PARAM(state);
2929 UNUSED_PARAM(throwScope);
2930 auto& impl = castedThis->wrapped();
2931 if (UNLIKELY(state->argumentCount() < 1))
2932 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2933 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "hasPausedImageAnimations", "Element"); });
2934 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2935 return JSValue::encode(toJS<IDLBoolean>(impl.hasPausedImageAnimations(*element)));
2936}
2937
2938EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasPausedImageAnimations(ExecState* state)
2939{
2940 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasPausedImageAnimationsBody>(*state, "hasPausedImageAnimations");
2941}
2942
2943static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPaintingFrequentlyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2944{
2945 UNUSED_PARAM(state);
2946 UNUSED_PARAM(throwScope);
2947 auto& impl = castedThis->wrapped();
2948 if (UNLIKELY(state->argumentCount() < 1))
2949 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2950 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPaintingFrequently", "Element"); });
2951 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2952 return JSValue::encode(toJS<IDLBoolean>(impl.isPaintingFrequently(*element)));
2953}
2954
2955EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPaintingFrequently(ExecState* state)
2956{
2957 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPaintingFrequentlyBody>(*state, "isPaintingFrequently");
2958}
2959
2960static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIncrementFrequentPaintCounterBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2961{
2962 UNUSED_PARAM(state);
2963 UNUSED_PARAM(throwScope);
2964 auto& impl = castedThis->wrapped();
2965 if (UNLIKELY(state->argumentCount() < 1))
2966 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2967 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "incrementFrequentPaintCounter", "Element"); });
2968 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2969 impl.incrementFrequentPaintCounter(*element);
2970 return JSValue::encode(jsUndefined());
2971}
2972
2973EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIncrementFrequentPaintCounter(ExecState* state)
2974{
2975 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIncrementFrequentPaintCounterBody>(*state, "incrementFrequentPaintCounter");
2976}
2977
2978static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementRenderTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2979{
2980 UNUSED_PARAM(state);
2981 UNUSED_PARAM(throwScope);
2982 auto& impl = castedThis->wrapped();
2983 if (UNLIKELY(state->argumentCount() < 1))
2984 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
2985 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "elementRenderTreeAsText", "Element"); });
2986 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2987 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.elementRenderTreeAsText(*element)));
2988}
2989
2990EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementRenderTreeAsText(ExecState* state)
2991{
2992 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementRenderTreeAsTextBody>(*state, "elementRenderTreeAsText");
2993}
2994
2995static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPreloadedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2996{
2997 UNUSED_PARAM(state);
2998 UNUSED_PARAM(throwScope);
2999 auto& impl = castedThis->wrapped();
3000 if (UNLIKELY(state->argumentCount() < 1))
3001 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3002 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3003 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3004 return JSValue::encode(toJS<IDLBoolean>(impl.isPreloaded(WTFMove(url))));
3005}
3006
3007EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPreloaded(ExecState* state)
3008{
3009 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPreloadedBody>(*state, "isPreloaded");
3010}
3011
3012static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsLoadingFromMemoryCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3013{
3014 UNUSED_PARAM(state);
3015 UNUSED_PARAM(throwScope);
3016 auto& impl = castedThis->wrapped();
3017 if (UNLIKELY(state->argumentCount() < 1))
3018 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3019 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3020 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3021 return JSValue::encode(toJS<IDLBoolean>(impl.isLoadingFromMemoryCache(WTFMove(url))));
3022}
3023
3024EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsLoadingFromMemoryCache(ExecState* state)
3025{
3026 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsLoadingFromMemoryCacheBody>(*state, "isLoadingFromMemoryCache");
3027}
3028
3029static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFetchResponseSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3030{
3031 UNUSED_PARAM(state);
3032 UNUSED_PARAM(throwScope);
3033 auto& impl = castedThis->wrapped();
3034 if (UNLIKELY(state->argumentCount() < 1))
3035 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3036 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "fetchResponseSource", "FetchResponse"); });
3037 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3038 return JSValue::encode(toJS<IDLDOMString>(*state, impl.fetchResponseSource(*response)));
3039}
3040
3041EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFetchResponseSource(ExecState* state)
3042{
3043 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFetchResponseSourceBody>(*state, "fetchResponseSource");
3044}
3045
3046static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionXhrResponseSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3047{
3048 UNUSED_PARAM(state);
3049 UNUSED_PARAM(throwScope);
3050 auto& impl = castedThis->wrapped();
3051 if (UNLIKELY(state->argumentCount() < 1))
3052 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3053 auto xhr = convert<IDLInterface<XMLHttpRequest>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "xhr", "Internals", "xhrResponseSource", "XMLHttpRequest"); });
3054 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3055 return JSValue::encode(toJS<IDLDOMString>(*state, impl.xhrResponseSource(*xhr)));
3056}
3057
3058EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionXhrResponseSource(ExecState* state)
3059{
3060 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionXhrResponseSourceBody>(*state, "xhrResponseSource");
3061}
3062
3063static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSharingStyleSheetContentsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3064{
3065 UNUSED_PARAM(state);
3066 UNUSED_PARAM(throwScope);
3067 auto& impl = castedThis->wrapped();
3068 if (UNLIKELY(state->argumentCount() < 2))
3069 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3070 auto a = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "a", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
3071 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3072 auto b = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "b", "Internals", "isSharingStyleSheetContents", "HTMLLinkElement"); });
3073 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3074 return JSValue::encode(toJS<IDLBoolean>(impl.isSharingStyleSheetContents(*a, *b)));
3075}
3076
3077EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSharingStyleSheetContents(ExecState* state)
3078{
3079 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSharingStyleSheetContentsBody>(*state, "isSharingStyleSheetContents");
3080}
3081
3082static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3083{
3084 UNUSED_PARAM(state);
3085 UNUSED_PARAM(throwScope);
3086 auto& impl = castedThis->wrapped();
3087 if (UNLIKELY(state->argumentCount() < 1))
3088 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3089 auto link = convert<IDLInterface<HTMLLinkElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "link", "Internals", "isStyleSheetLoadingSubresources", "HTMLLinkElement"); });
3090 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3091 return JSValue::encode(toJS<IDLBoolean>(impl.isStyleSheetLoadingSubresources(*link)));
3092}
3093
3094EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresources(ExecState* state)
3095{
3096 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsStyleSheetLoadingSubresourcesBody>(*state, "isStyleSheetLoadingSubresources");
3097}
3098
3099static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearMemoryCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3100{
3101 UNUSED_PARAM(state);
3102 UNUSED_PARAM(throwScope);
3103 auto& impl = castedThis->wrapped();
3104 impl.clearMemoryCache();
3105 return JSValue::encode(jsUndefined());
3106}
3107
3108EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearMemoryCache(ExecState* state)
3109{
3110 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearMemoryCacheBody>(*state, "clearMemoryCache");
3111}
3112
3113static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPruneMemoryCacheToSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3114{
3115 UNUSED_PARAM(state);
3116 UNUSED_PARAM(throwScope);
3117 auto& impl = castedThis->wrapped();
3118 if (UNLIKELY(state->argumentCount() < 1))
3119 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3120 auto size = convert<IDLLong>(*state, state->uncheckedArgument(0));
3121 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3122 impl.pruneMemoryCacheToSize(WTFMove(size));
3123 return JSValue::encode(jsUndefined());
3124}
3125
3126EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPruneMemoryCacheToSize(ExecState* state)
3127{
3128 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPruneMemoryCacheToSizeBody>(*state, "pruneMemoryCacheToSize");
3129}
3130
3131static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDestroyDecodedDataForAllImagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3132{
3133 UNUSED_PARAM(state);
3134 UNUSED_PARAM(throwScope);
3135 auto& impl = castedThis->wrapped();
3136 impl.destroyDecodedDataForAllImages();
3137 return JSValue::encode(jsUndefined());
3138}
3139
3140EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDestroyDecodedDataForAllImages(ExecState* state)
3141{
3142 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDestroyDecodedDataForAllImagesBody>(*state, "destroyDecodedDataForAllImages");
3143}
3144
3145static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMemoryCacheSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3146{
3147 UNUSED_PARAM(state);
3148 UNUSED_PARAM(throwScope);
3149 auto& impl = castedThis->wrapped();
3150 return JSValue::encode(toJS<IDLLong>(impl.memoryCacheSize()));
3151}
3152
3153EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryCacheSize(ExecState* state)
3154{
3155 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMemoryCacheSizeBody>(*state, "memoryCacheSize");
3156}
3157
3158static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetOverrideCachePolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3159{
3160 UNUSED_PARAM(state);
3161 UNUSED_PARAM(throwScope);
3162 auto& impl = castedThis->wrapped();
3163 if (UNLIKELY(state->argumentCount() < 1))
3164 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3165 auto policy = convert<IDLEnumeration<Internals::CachePolicy>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "policy", "Internals", "setOverrideCachePolicy", expectedEnumerationValues<Internals::CachePolicy>()); });
3166 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3167 impl.setOverrideCachePolicy(WTFMove(policy));
3168 return JSValue::encode(jsUndefined());
3169}
3170
3171EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideCachePolicy(ExecState* state)
3172{
3173 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetOverrideCachePolicyBody>(*state, "setOverrideCachePolicy");
3174}
3175
3176static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetOverrideResourceLoadPriorityBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3177{
3178 UNUSED_PARAM(state);
3179 UNUSED_PARAM(throwScope);
3180 auto& impl = castedThis->wrapped();
3181 if (UNLIKELY(state->argumentCount() < 1))
3182 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3183 auto priority = convert<IDLEnumeration<Internals::ResourceLoadPriority>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "priority", "Internals", "setOverrideResourceLoadPriority", expectedEnumerationValues<Internals::ResourceLoadPriority>()); });
3184 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3185 impl.setOverrideResourceLoadPriority(WTFMove(priority));
3186 return JSValue::encode(jsUndefined());
3187}
3188
3189EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetOverrideResourceLoadPriority(ExecState* state)
3190{
3191 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetOverrideResourceLoadPriorityBody>(*state, "setOverrideResourceLoadPriority");
3192}
3193
3194static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3195{
3196 UNUSED_PARAM(state);
3197 UNUSED_PARAM(throwScope);
3198 auto& impl = castedThis->wrapped();
3199 if (UNLIKELY(state->argumentCount() < 1))
3200 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3201 auto disabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3202 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3203 impl.setStrictRawResourceValidationPolicyDisabled(WTFMove(disabled));
3204 return JSValue::encode(jsUndefined());
3205}
3206
3207EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabled(ExecState* state)
3208{
3209 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetStrictRawResourceValidationPolicyDisabledBody>(*state, "setStrictRawResourceValidationPolicyDisabled");
3210}
3211
3212static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearPageCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3213{
3214 UNUSED_PARAM(state);
3215 UNUSED_PARAM(throwScope);
3216 auto& impl = castedThis->wrapped();
3217 impl.clearPageCache();
3218 return JSValue::encode(jsUndefined());
3219}
3220
3221EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPageCache(ExecState* state)
3222{
3223 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearPageCacheBody>(*state, "clearPageCache");
3224}
3225
3226static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageCacheSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3227{
3228 UNUSED_PARAM(state);
3229 UNUSED_PARAM(throwScope);
3230 auto& impl = castedThis->wrapped();
3231 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pageCacheSize()));
3232}
3233
3234EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageCacheSize(ExecState* state)
3235{
3236 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageCacheSizeBody>(*state, "pageCacheSize");
3237}
3238
3239static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3240{
3241 UNUSED_PARAM(state);
3242 UNUSED_PARAM(throwScope);
3243 auto& impl = castedThis->wrapped();
3244 if (UNLIKELY(state->argumentCount() < 1))
3245 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3246 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "computedStyleIncludingVisitedInfo", "Element"); });
3247 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3248 return JSValue::encode(toJS<IDLInterface<CSSStyleDeclaration>>(*state, *castedThis->globalObject(), impl.computedStyleIncludingVisitedInfo(*element)));
3249}
3250
3251EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfo(ExecState* state)
3252{
3253 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionComputedStyleIncludingVisitedInfoBody>(*state, "computedStyleIncludingVisitedInfo");
3254}
3255
3256static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnsureUserAgentShadowRootBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3257{
3258 UNUSED_PARAM(state);
3259 UNUSED_PARAM(throwScope);
3260 auto& impl = castedThis->wrapped();
3261 if (UNLIKELY(state->argumentCount() < 1))
3262 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3263 auto host = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "host", "Internals", "ensureUserAgentShadowRoot", "Element"); });
3264 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3265 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.ensureUserAgentShadowRoot(*host)));
3266}
3267
3268EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnsureUserAgentShadowRoot(ExecState* state)
3269{
3270 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnsureUserAgentShadowRootBody>(*state, "ensureUserAgentShadowRoot");
3271}
3272
3273static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowRootBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3274{
3275 UNUSED_PARAM(state);
3276 UNUSED_PARAM(throwScope);
3277 auto& impl = castedThis->wrapped();
3278 if (UNLIKELY(state->argumentCount() < 1))
3279 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3280 auto host = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "host", "Internals", "shadowRoot", "Element"); });
3281 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3282 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.shadowRoot(*host)));
3283}
3284
3285EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRoot(ExecState* state)
3286{
3287 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowRootBody>(*state, "shadowRoot");
3288}
3289
3290static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredStyleRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3291{
3292 UNUSED_PARAM(state);
3293 UNUSED_PARAM(throwScope);
3294 auto& impl = castedThis->wrapped();
3295 if (UNLIKELY(state->argumentCount() < 1))
3296 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3297 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredStyleRulesCount", "StyleSheet"); });
3298 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3299 return JSValue::encode(toJS<IDLLong>(impl.deferredStyleRulesCount(*sheet)));
3300}
3301
3302EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredStyleRulesCount(ExecState* state)
3303{
3304 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredStyleRulesCountBody>(*state, "deferredStyleRulesCount");
3305}
3306
3307static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredGroupRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3308{
3309 UNUSED_PARAM(state);
3310 UNUSED_PARAM(throwScope);
3311 auto& impl = castedThis->wrapped();
3312 if (UNLIKELY(state->argumentCount() < 1))
3313 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3314 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredGroupRulesCount", "StyleSheet"); });
3315 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3316 return JSValue::encode(toJS<IDLLong>(impl.deferredGroupRulesCount(*sheet)));
3317}
3318
3319EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredGroupRulesCount(ExecState* state)
3320{
3321 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredGroupRulesCountBody>(*state, "deferredGroupRulesCount");
3322}
3323
3324static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeferredKeyframesRulesCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3325{
3326 UNUSED_PARAM(state);
3327 UNUSED_PARAM(throwScope);
3328 auto& impl = castedThis->wrapped();
3329 if (UNLIKELY(state->argumentCount() < 1))
3330 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3331 auto sheet = convert<IDLInterface<StyleSheet>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "sheet", "Internals", "deferredKeyframesRulesCount", "StyleSheet"); });
3332 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3333 return JSValue::encode(toJS<IDLLong>(impl.deferredKeyframesRulesCount(*sheet)));
3334}
3335
3336EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeferredKeyframesRulesCount(ExecState* state)
3337{
3338 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeferredKeyframesRulesCountBody>(*state, "deferredKeyframesRulesCount");
3339}
3340
3341static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowRootTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3342{
3343 UNUSED_PARAM(state);
3344 UNUSED_PARAM(throwScope);
3345 auto& impl = castedThis->wrapped();
3346 if (UNLIKELY(state->argumentCount() < 1))
3347 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3348 auto root = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "root", "Internals", "shadowRootType", "Node"); });
3349 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3350 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.shadowRootType(*root)));
3351}
3352
3353EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowRootType(ExecState* state)
3354{
3355 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowRootTypeBody>(*state, "shadowRootType");
3356}
3357
3358static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShadowPseudoIdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3359{
3360 UNUSED_PARAM(state);
3361 UNUSED_PARAM(throwScope);
3362 auto& impl = castedThis->wrapped();
3363 if (UNLIKELY(state->argumentCount() < 1))
3364 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3365 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "shadowPseudoId", "Element"); });
3366 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3367 return JSValue::encode(toJS<IDLDOMString>(*state, impl.shadowPseudoId(*element)));
3368}
3369
3370EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShadowPseudoId(ExecState* state)
3371{
3372 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShadowPseudoIdBody>(*state, "shadowPseudoId");
3373}
3374
3375static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShadowPseudoIdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3376{
3377 UNUSED_PARAM(state);
3378 UNUSED_PARAM(throwScope);
3379 auto& impl = castedThis->wrapped();
3380 if (UNLIKELY(state->argumentCount() < 2))
3381 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3382 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setShadowPseudoId", "Element"); });
3383 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3384 auto id = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3385 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3386 impl.setShadowPseudoId(*element, WTFMove(id));
3387 return JSValue::encode(jsUndefined());
3388}
3389
3390EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShadowPseudoId(ExecState* state)
3391{
3392 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShadowPseudoIdBody>(*state, "setShadowPseudoId");
3393}
3394
3395static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTreeScopeRootNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3396{
3397 UNUSED_PARAM(state);
3398 UNUSED_PARAM(throwScope);
3399 auto& impl = castedThis->wrapped();
3400 if (UNLIKELY(state->argumentCount() < 1))
3401 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3402 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "treeScopeRootNode", "Node"); });
3403 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3404 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.treeScopeRootNode(*node)));
3405}
3406
3407EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTreeScopeRootNode(ExecState* state)
3408{
3409 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTreeScopeRootNodeBody>(*state, "treeScopeRootNode");
3410}
3411
3412static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParentTreeScopeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3413{
3414 UNUSED_PARAM(state);
3415 UNUSED_PARAM(throwScope);
3416 auto& impl = castedThis->wrapped();
3417 if (UNLIKELY(state->argumentCount() < 1))
3418 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3419 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "parentTreeScope", "Node"); });
3420 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3421 return JSValue::encode(toJS<IDLInterface<Node>>(*state, *castedThis->globalObject(), impl.parentTreeScope(*node)));
3422}
3423
3424EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParentTreeScope(ExecState* state)
3425{
3426 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParentTreeScopeBody>(*state, "parentTreeScope");
3427}
3428
3429static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3430{
3431 UNUSED_PARAM(state);
3432 UNUSED_PARAM(throwScope);
3433 auto& impl = castedThis->wrapped();
3434 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.lastSpatialNavigationCandidateCount()));
3435}
3436
3437EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCount(ExecState* state)
3438{
3439 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpatialNavigationCandidateCountBody>(*state, "lastSpatialNavigationCandidateCount");
3440}
3441
3442static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfActiveAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3443{
3444 UNUSED_PARAM(state);
3445 UNUSED_PARAM(throwScope);
3446 auto& impl = castedThis->wrapped();
3447 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfActiveAnimations()));
3448}
3449
3450EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfActiveAnimations(ExecState* state)
3451{
3452 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfActiveAnimationsBody>(*state, "numberOfActiveAnimations");
3453}
3454
3455static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSuspendAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3456{
3457 UNUSED_PARAM(state);
3458 UNUSED_PARAM(throwScope);
3459 auto& impl = castedThis->wrapped();
3460 propagateException(*state, throwScope, impl.suspendAnimations());
3461 return JSValue::encode(jsUndefined());
3462}
3463
3464EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSuspendAnimations(ExecState* state)
3465{
3466 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSuspendAnimationsBody>(*state, "suspendAnimations");
3467}
3468
3469static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResumeAnimationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3470{
3471 UNUSED_PARAM(state);
3472 UNUSED_PARAM(throwScope);
3473 auto& impl = castedThis->wrapped();
3474 propagateException(*state, throwScope, impl.resumeAnimations());
3475 return JSValue::encode(jsUndefined());
3476}
3477
3478EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResumeAnimations(ExecState* state)
3479{
3480 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResumeAnimationsBody>(*state, "resumeAnimations");
3481}
3482
3483static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAnimationsAreSuspendedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3484{
3485 UNUSED_PARAM(state);
3486 UNUSED_PARAM(throwScope);
3487 auto& impl = castedThis->wrapped();
3488 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.animationsAreSuspended()));
3489}
3490
3491EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAnimationsAreSuspended(ExecState* state)
3492{
3493 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAnimationsAreSuspendedBody>(*state, "animationsAreSuspended");
3494}
3495
3496static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3497{
3498 UNUSED_PARAM(state);
3499 UNUSED_PARAM(throwScope);
3500 auto& impl = castedThis->wrapped();
3501 if (UNLIKELY(state->argumentCount() < 3))
3502 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3503 auto animationName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3504 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3505 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3506 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3507 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseAnimationAtTimeOnElement", "Element"); });
3508 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3509 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseAnimationAtTimeOnElement(WTFMove(animationName), WTFMove(pauseTime), *element)));
3510}
3511
3512EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElement(ExecState* state)
3513{
3514 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseAnimationAtTimeOnElementBody>(*state, "pauseAnimationAtTimeOnElement");
3515}
3516
3517static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3518{
3519 UNUSED_PARAM(state);
3520 UNUSED_PARAM(throwScope);
3521 auto& impl = castedThis->wrapped();
3522 if (UNLIKELY(state->argumentCount() < 4))
3523 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3524 auto animationName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3525 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3526 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3527 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3528 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseAnimationAtTimeOnPseudoElement", "Element"); });
3529 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3530 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(3));
3531 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3532 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseAnimationAtTimeOnPseudoElement(WTFMove(animationName), WTFMove(pauseTime), *element, WTFMove(pseudoId))));
3533}
3534
3535EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElement(ExecState* state)
3536{
3537 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseAnimationAtTimeOnPseudoElementBody>(*state, "pauseAnimationAtTimeOnPseudoElement");
3538}
3539
3540static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3541{
3542 UNUSED_PARAM(state);
3543 UNUSED_PARAM(throwScope);
3544 auto& impl = castedThis->wrapped();
3545 if (UNLIKELY(state->argumentCount() < 3))
3546 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3547 auto propertyName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3548 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3549 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3550 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3551 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseTransitionAtTimeOnElement", "Element"); });
3552 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3553 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseTransitionAtTimeOnElement(WTFMove(propertyName), WTFMove(pauseTime), *element)));
3554}
3555
3556EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElement(ExecState* state)
3557{
3558 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseTransitionAtTimeOnElementBody>(*state, "pauseTransitionAtTimeOnElement");
3559}
3560
3561static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3562{
3563 UNUSED_PARAM(state);
3564 UNUSED_PARAM(throwScope);
3565 auto& impl = castedThis->wrapped();
3566 if (UNLIKELY(state->argumentCount() < 4))
3567 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3568 auto property = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3570 auto pauseTime = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3571 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3572 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "element", "Internals", "pauseTransitionAtTimeOnPseudoElement", "Element"); });
3573 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3574 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(3));
3575 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3576 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pauseTransitionAtTimeOnPseudoElement(WTFMove(property), WTFMove(pauseTime), *element, WTFMove(pseudoId))));
3577}
3578
3579EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElement(ExecState* state)
3580{
3581 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPauseTransitionAtTimeOnPseudoElementBody>(*state, "pauseTransitionAtTimeOnPseudoElement");
3582}
3583
3584static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAcceleratedAnimationsForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3585{
3586 UNUSED_PARAM(state);
3587 UNUSED_PARAM(throwScope);
3588 auto& impl = castedThis->wrapped();
3589 if (UNLIKELY(state->argumentCount() < 1))
3590 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3591 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "acceleratedAnimationsForElement", "Element"); });
3592 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3593 return JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::AcceleratedAnimation>>>(*state, *castedThis->globalObject(), impl.acceleratedAnimationsForElement(*element)));
3594}
3595
3596EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAcceleratedAnimationsForElement(ExecState* state)
3597{
3598 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAcceleratedAnimationsForElementBody>(*state, "acceleratedAnimationsForElement");
3599}
3600
3601static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidationsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3602{
3603 UNUSED_PARAM(state);
3604 UNUSED_PARAM(throwScope);
3605 auto& impl = castedThis->wrapped();
3606 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfAnimationTimelineInvalidations()));
3607}
3608
3609EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidations(ExecState* state)
3610{
3611 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfAnimationTimelineInvalidationsBody>(*state, "numberOfAnimationTimelineInvalidations");
3612}
3613
3614static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPseudoElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3615{
3616 UNUSED_PARAM(state);
3617 UNUSED_PARAM(throwScope);
3618 auto& impl = castedThis->wrapped();
3619 if (UNLIKELY(state->argumentCount() < 2))
3620 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3621 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pseudoElement", "Element"); });
3622 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3623 auto pseudoId = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3624 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3625 return JSValue::encode(toJS<IDLNullable<IDLInterface<Element>>>(*state, *castedThis->globalObject(), throwScope, impl.pseudoElement(*element, WTFMove(pseudoId))));
3626}
3627
3628EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPseudoElement(ExecState* state)
3629{
3630 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPseudoElementBody>(*state, "pseudoElement");
3631}
3632
3633static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionVisiblePlaceholderBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3634{
3635 UNUSED_PARAM(state);
3636 UNUSED_PARAM(throwScope);
3637 auto& impl = castedThis->wrapped();
3638 if (UNLIKELY(state->argumentCount() < 1))
3639 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3640 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "visiblePlaceholder", "Element"); });
3641 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3642 return JSValue::encode(toJS<IDLDOMString>(*state, impl.visiblePlaceholder(*element)));
3643}
3644
3645EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisiblePlaceholder(ExecState* state)
3646{
3647 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionVisiblePlaceholderBody>(*state, "visiblePlaceholder");
3648}
3649
3650static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSelectColorInColorChooserBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3651{
3652 UNUSED_PARAM(state);
3653 UNUSED_PARAM(throwScope);
3654 auto& impl = castedThis->wrapped();
3655 if (UNLIKELY(state->argumentCount() < 2))
3656 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3657 auto element = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "selectColorInColorChooser", "HTMLInputElement"); });
3658 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3659 auto colorValue = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3660 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3661 impl.selectColorInColorChooser(*element, WTFMove(colorValue));
3662 return JSValue::encode(jsUndefined());
3663}
3664
3665EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectColorInColorChooser(ExecState* state)
3666{
3667 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSelectColorInColorChooserBody>(*state, "selectColorInColorChooser");
3668}
3669
3670static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3671{
3672 UNUSED_PARAM(state);
3673 UNUSED_PARAM(throwScope);
3674 auto& impl = castedThis->wrapped();
3675 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), throwScope, impl.formControlStateOfPreviousHistoryItem()));
3676}
3677
3678EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItem(ExecState* state)
3679{
3680 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFormControlStateOfPreviousHistoryItemBody>(*state, "formControlStateOfPreviousHistoryItem");
3681}
3682
3683static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3684{
3685 UNUSED_PARAM(state);
3686 UNUSED_PARAM(throwScope);
3687 auto& impl = castedThis->wrapped();
3688 if (UNLIKELY(state->argumentCount() < 1))
3689 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3690 auto values = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(0));
3691 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3692 propagateException(*state, throwScope, impl.setFormControlStateOfPreviousHistoryItem(WTFMove(values)));
3693 return JSValue::encode(jsUndefined());
3694}
3695
3696EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItem(ExecState* state)
3697{
3698 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFormControlStateOfPreviousHistoryItemBody>(*state, "setFormControlStateOfPreviousHistoryItem");
3699}
3700
3701static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAbsoluteCaretBoundsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3702{
3703 UNUSED_PARAM(state);
3704 UNUSED_PARAM(throwScope);
3705 auto& impl = castedThis->wrapped();
3706 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.absoluteCaretBounds()));
3707}
3708
3709EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAbsoluteCaretBounds(ExecState* state)
3710{
3711 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAbsoluteCaretBoundsBody>(*state, "absoluteCaretBounds");
3712}
3713
3714static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsCaretBlinkingSuspendedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3715{
3716 UNUSED_PARAM(state);
3717 UNUSED_PARAM(throwScope);
3718 auto& impl = castedThis->wrapped();
3719 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isCaretBlinkingSuspended()));
3720}
3721
3722EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsCaretBlinkingSuspended(ExecState* state)
3723{
3724 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsCaretBlinkingSuspendedBody>(*state, "isCaretBlinkingSuspended");
3725}
3726
3727static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBoundingBoxBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3728{
3729 UNUSED_PARAM(state);
3730 UNUSED_PARAM(throwScope);
3731 auto& impl = castedThis->wrapped();
3732 if (UNLIKELY(state->argumentCount() < 1))
3733 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3734 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "boundingBox", "Element"); });
3735 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3736 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), impl.boundingBox(*element)));
3737}
3738
3739EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBoundingBox(ExecState* state)
3740{
3741 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBoundingBoxBody>(*state, "boundingBox");
3742}
3743
3744static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInspectorHighlightRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3745{
3746 UNUSED_PARAM(state);
3747 UNUSED_PARAM(throwScope);
3748 auto& impl = castedThis->wrapped();
3749 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.inspectorHighlightRects()));
3750}
3751
3752EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInspectorHighlightRects(ExecState* state)
3753{
3754 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInspectorHighlightRectsBody>(*state, "inspectorHighlightRects");
3755}
3756
3757static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerCountForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3758{
3759 UNUSED_PARAM(state);
3760 UNUSED_PARAM(throwScope);
3761 auto& impl = castedThis->wrapped();
3762 if (UNLIKELY(state->argumentCount() < 2))
3763 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3764 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerCountForNode", "Node"); });
3765 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3766 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3767 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3768 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.markerCountForNode(*node, WTFMove(markerType))));
3769}
3770
3771EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerCountForNode(ExecState* state)
3772{
3773 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerCountForNodeBody>(*state, "markerCountForNode");
3774}
3775
3776static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerRangeForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3777{
3778 UNUSED_PARAM(state);
3779 UNUSED_PARAM(throwScope);
3780 auto& impl = castedThis->wrapped();
3781 if (UNLIKELY(state->argumentCount() < 3))
3782 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3783 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerRangeForNode", "Node"); });
3784 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3785 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3786 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3787 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
3788 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3789 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.markerRangeForNode(*node, WTFMove(markerType), WTFMove(index))));
3790}
3791
3792EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerRangeForNode(ExecState* state)
3793{
3794 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerRangeForNodeBody>(*state, "markerRangeForNode");
3795}
3796
3797static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerDescriptionForNodeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3798{
3799 UNUSED_PARAM(state);
3800 UNUSED_PARAM(throwScope);
3801 auto& impl = castedThis->wrapped();
3802 if (UNLIKELY(state->argumentCount() < 3))
3803 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3804 auto node = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "markerDescriptionForNode", "Node"); });
3805 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3806 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
3807 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3808 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
3809 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3810 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.markerDescriptionForNode(*node, WTFMove(markerType), WTFMove(index))));
3811}
3812
3813EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerDescriptionForNode(ExecState* state)
3814{
3815 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerDescriptionForNodeBody>(*state, "markerDescriptionForNode");
3816}
3817
3818static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDumpMarkerRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3819{
3820 UNUSED_PARAM(state);
3821 UNUSED_PARAM(throwScope);
3822 auto& impl = castedThis->wrapped();
3823 if (UNLIKELY(state->argumentCount() < 1))
3824 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3825 auto markerType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
3826 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3827 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.dumpMarkerRects(WTFMove(markerType))));
3828}
3829
3830EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDumpMarkerRects(ExecState* state)
3831{
3832 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDumpMarkerRectsBody>(*state, "dumpMarkerRects");
3833}
3834
3835static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAddTextMatchMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3836{
3837 UNUSED_PARAM(state);
3838 UNUSED_PARAM(throwScope);
3839 auto& impl = castedThis->wrapped();
3840 if (UNLIKELY(state->argumentCount() < 2))
3841 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3842 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "addTextMatchMarker", "Range"); });
3843 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3844 auto isActive = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
3845 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3846 impl.addTextMatchMarker(*range, WTFMove(isActive));
3847 return JSValue::encode(jsUndefined());
3848}
3849
3850EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAddTextMatchMarker(ExecState* state)
3851{
3852 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAddTextMatchMarkerBody>(*state, "addTextMatchMarker");
3853}
3854
3855static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlightedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3856{
3857 UNUSED_PARAM(state);
3858 UNUSED_PARAM(throwScope);
3859 auto& impl = castedThis->wrapped();
3860 if (UNLIKELY(state->argumentCount() < 1))
3861 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3862 auto flag = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3863 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3864 propagateException(*state, throwScope, impl.setMarkedTextMatchesAreHighlighted(WTFMove(flag)));
3865 return JSValue::encode(jsUndefined());
3866}
3867
3868EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlighted(ExecState* state)
3869{
3870 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMarkedTextMatchesAreHighlightedBody>(*state, "setMarkedTextMatchesAreHighlighted");
3871}
3872
3873static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInvalidateFontCacheBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3874{
3875 UNUSED_PARAM(state);
3876 UNUSED_PARAM(throwScope);
3877 auto& impl = castedThis->wrapped();
3878 impl.invalidateFontCache();
3879 return JSValue::encode(jsUndefined());
3880}
3881
3882EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateFontCache(ExecState* state)
3883{
3884 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInvalidateFontCacheBody>(*state, "invalidateFontCache");
3885}
3886
3887static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFontSmoothingEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3888{
3889 UNUSED_PARAM(state);
3890 UNUSED_PARAM(throwScope);
3891 auto& impl = castedThis->wrapped();
3892 if (UNLIKELY(state->argumentCount() < 1))
3893 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3894 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3895 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3896 impl.setFontSmoothingEnabled(WTFMove(enabled));
3897 return JSValue::encode(jsUndefined());
3898}
3899
3900EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFontSmoothingEnabled(ExecState* state)
3901{
3902 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFontSmoothingEnabledBody>(*state, "setFontSmoothingEnabled");
3903}
3904
3905static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetScrollViewPositionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3906{
3907 UNUSED_PARAM(state);
3908 UNUSED_PARAM(throwScope);
3909 auto& impl = castedThis->wrapped();
3910 if (UNLIKELY(state->argumentCount() < 2))
3911 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3912 auto x = convert<IDLLong>(*state, state->uncheckedArgument(0));
3913 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3914 auto y = convert<IDLLong>(*state, state->uncheckedArgument(1));
3915 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3916 propagateException(*state, throwScope, impl.setScrollViewPosition(WTFMove(x), WTFMove(y)));
3917 return JSValue::encode(jsUndefined());
3918}
3919
3920EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetScrollViewPosition(ExecState* state)
3921{
3922 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetScrollViewPositionBody>(*state, "setScrollViewPosition");
3923}
3924
3925static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUnconstrainedScrollToBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3926{
3927 UNUSED_PARAM(state);
3928 UNUSED_PARAM(throwScope);
3929 auto& impl = castedThis->wrapped();
3930 if (UNLIKELY(state->argumentCount() < 3))
3931 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3932 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "unconstrainedScrollTo", "Element"); });
3933 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3934 auto x = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
3935 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3936 auto y = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(2));
3937 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3938 propagateException(*state, throwScope, impl.unconstrainedScrollTo(*element, WTFMove(x), WTFMove(y)));
3939 return JSValue::encode(jsUndefined());
3940}
3941
3942EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnconstrainedScrollTo(ExecState* state)
3943{
3944 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUnconstrainedScrollToBody>(*state, "unconstrainedScrollTo");
3945}
3946
3947static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayoutViewportRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3948{
3949 UNUSED_PARAM(state);
3950 UNUSED_PARAM(throwScope);
3951 auto& impl = castedThis->wrapped();
3952 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.layoutViewportRect()));
3953}
3954
3955EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayoutViewportRect(ExecState* state)
3956{
3957 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayoutViewportRectBody>(*state, "layoutViewportRect");
3958}
3959
3960static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionVisualViewportRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3961{
3962 UNUSED_PARAM(state);
3963 UNUSED_PARAM(throwScope);
3964 auto& impl = castedThis->wrapped();
3965 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.visualViewportRect()));
3966}
3967
3968EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionVisualViewportRect(ExecState* state)
3969{
3970 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionVisualViewportRectBody>(*state, "visualViewportRect");
3971}
3972
3973static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewIsTransparentBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3974{
3975 UNUSED_PARAM(state);
3976 UNUSED_PARAM(throwScope);
3977 auto& impl = castedThis->wrapped();
3978 if (UNLIKELY(state->argumentCount() < 1))
3979 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
3980 auto trnasparent = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
3981 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
3982 propagateException(*state, throwScope, impl.setViewIsTransparent(WTFMove(trnasparent)));
3983 return JSValue::encode(jsUndefined());
3984}
3985
3986EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewIsTransparent(ExecState* state)
3987{
3988 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewIsTransparentBody>(*state, "setViewIsTransparent");
3989}
3990
3991static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionViewBaseBackgroundColorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
3992{
3993 UNUSED_PARAM(state);
3994 UNUSED_PARAM(throwScope);
3995 auto& impl = castedThis->wrapped();
3996 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.viewBaseBackgroundColor()));
3997}
3998
3999EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionViewBaseBackgroundColor(ExecState* state)
4000{
4001 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionViewBaseBackgroundColorBody>(*state, "viewBaseBackgroundColor");
4002}
4003
4004static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewBaseBackgroundColorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4005{
4006 UNUSED_PARAM(state);
4007 UNUSED_PARAM(throwScope);
4008 auto& impl = castedThis->wrapped();
4009 if (UNLIKELY(state->argumentCount() < 1))
4010 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4011 auto colorValue = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4012 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4013 propagateException(*state, throwScope, impl.setViewBaseBackgroundColor(WTFMove(colorValue)));
4014 return JSValue::encode(jsUndefined());
4015}
4016
4017EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewBaseBackgroundColor(ExecState* state)
4018{
4019 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewBaseBackgroundColorBody>(*state, "setViewBaseBackgroundColor");
4020}
4021
4022static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPaginationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4023{
4024 UNUSED_PARAM(state);
4025 UNUSED_PARAM(throwScope);
4026 auto& impl = castedThis->wrapped();
4027 if (UNLIKELY(state->argumentCount() < 2))
4028 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4029 auto mode = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4030 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4031 auto gap = convert<IDLLong>(*state, state->uncheckedArgument(1));
4032 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4033 auto pageLength = convert<IDLLong>(*state, state->argument(2));
4034 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4035 propagateException(*state, throwScope, impl.setPagination(WTFMove(mode), WTFMove(gap), WTFMove(pageLength)));
4036 return JSValue::encode(jsUndefined());
4037}
4038
4039EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPagination(ExecState* state)
4040{
4041 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPaginationBody>(*state, "setPagination");
4042}
4043
4044static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPaginationLineGridEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4045{
4046 UNUSED_PARAM(state);
4047 UNUSED_PARAM(throwScope);
4048 auto& impl = castedThis->wrapped();
4049 if (UNLIKELY(state->argumentCount() < 1))
4050 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4051 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4052 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4053 propagateException(*state, throwScope, impl.setPaginationLineGridEnabled(WTFMove(enabled)));
4054 return JSValue::encode(jsUndefined());
4055}
4056
4057EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPaginationLineGridEnabled(ExecState* state)
4058{
4059 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPaginationLineGridEnabledBody>(*state, "setPaginationLineGridEnabled");
4060}
4061
4062static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionConfigurationForViewportBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4063{
4064 UNUSED_PARAM(state);
4065 UNUSED_PARAM(throwScope);
4066 auto& impl = castedThis->wrapped();
4067 if (UNLIKELY(state->argumentCount() < 5))
4068 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4069 auto devicePixelRatio = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
4070 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4071 auto deviceWidth = convert<IDLLong>(*state, state->uncheckedArgument(1));
4072 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4073 auto deviceHeight = convert<IDLLong>(*state, state->uncheckedArgument(2));
4074 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4075 auto availableWidth = convert<IDLLong>(*state, state->uncheckedArgument(3));
4076 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4077 auto availableHeight = convert<IDLLong>(*state, state->uncheckedArgument(4));
4078 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4079 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.configurationForViewport(WTFMove(devicePixelRatio), WTFMove(deviceWidth), WTFMove(deviceHeight), WTFMove(availableWidth), WTFMove(availableHeight))));
4080}
4081
4082EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionConfigurationForViewport(ExecState* state)
4083{
4084 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionConfigurationForViewportBody>(*state, "configurationForViewport");
4085}
4086
4087static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWasLastChangeUserEditBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4088{
4089 UNUSED_PARAM(state);
4090 UNUSED_PARAM(throwScope);
4091 auto& impl = castedThis->wrapped();
4092 if (UNLIKELY(state->argumentCount() < 1))
4093 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4094 auto textField = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "textField", "Internals", "wasLastChangeUserEdit", "Element"); });
4095 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4096 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.wasLastChangeUserEdit(*textField)));
4097}
4098
4099EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWasLastChangeUserEdit(ExecState* state)
4100{
4101 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWasLastChangeUserEditBody>(*state, "wasLastChangeUserEdit");
4102}
4103
4104static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementShouldAutoCompleteBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4105{
4106 UNUSED_PARAM(state);
4107 UNUSED_PARAM(throwScope);
4108 auto& impl = castedThis->wrapped();
4109 if (UNLIKELY(state->argumentCount() < 1))
4110 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4111 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "elementShouldAutoComplete", "HTMLInputElement"); });
4112 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4113 return JSValue::encode(toJS<IDLBoolean>(impl.elementShouldAutoComplete(*inputElement)));
4114}
4115
4116EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldAutoComplete(ExecState* state)
4117{
4118 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementShouldAutoCompleteBody>(*state, "elementShouldAutoComplete");
4119}
4120
4121static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutofilledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4122{
4123 UNUSED_PARAM(state);
4124 UNUSED_PARAM(throwScope);
4125 auto& impl = castedThis->wrapped();
4126 if (UNLIKELY(state->argumentCount() < 2))
4127 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4128 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "setAutofilled", "HTMLInputElement"); });
4129 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4130 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
4131 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4132 impl.setAutofilled(*inputElement, WTFMove(enabled));
4133 return JSValue::encode(jsUndefined());
4134}
4135
4136EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutofilled(ExecState* state)
4137{
4138 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutofilledBody>(*state, "setAutofilled");
4139}
4140
4141static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShowAutoFillButtonBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4142{
4143 UNUSED_PARAM(state);
4144 UNUSED_PARAM(throwScope);
4145 auto& impl = castedThis->wrapped();
4146 if (UNLIKELY(state->argumentCount() < 2))
4147 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4148 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "setShowAutoFillButton", "HTMLInputElement"); });
4149 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4150 auto autoFillButtonType = convert<IDLEnumeration<Internals::AutoFillButtonType>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 1, "autoFillButtonType", "Internals", "setShowAutoFillButton", expectedEnumerationValues<Internals::AutoFillButtonType>()); });
4151 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4152 impl.setShowAutoFillButton(*inputElement, WTFMove(autoFillButtonType));
4153 return JSValue::encode(jsUndefined());
4154}
4155
4156EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAutoFillButton(ExecState* state)
4157{
4158 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShowAutoFillButtonBody>(*state, "setShowAutoFillButton");
4159}
4160
4161static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAutoFillButtonTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4162{
4163 UNUSED_PARAM(state);
4164 UNUSED_PARAM(throwScope);
4165 auto& impl = castedThis->wrapped();
4166 if (UNLIKELY(state->argumentCount() < 1))
4167 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4168 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "autoFillButtonType", "HTMLInputElement"); });
4169 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4170 return JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*state, impl.autoFillButtonType(*inputElement)));
4171}
4172
4173EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutoFillButtonType(ExecState* state)
4174{
4175 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAutoFillButtonTypeBody>(*state, "autoFillButtonType");
4176}
4177
4178static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastAutoFillButtonTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4179{
4180 UNUSED_PARAM(state);
4181 UNUSED_PARAM(throwScope);
4182 auto& impl = castedThis->wrapped();
4183 if (UNLIKELY(state->argumentCount() < 1))
4184 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4185 auto inputElement = convert<IDLInterface<HTMLInputElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "inputElement", "Internals", "lastAutoFillButtonType", "HTMLInputElement"); });
4186 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4187 return JSValue::encode(toJS<IDLEnumeration<Internals::AutoFillButtonType>>(*state, impl.lastAutoFillButtonType(*inputElement)));
4188}
4189
4190EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastAutoFillButtonType(ExecState* state)
4191{
4192 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastAutoFillButtonTypeBody>(*state, "lastAutoFillButtonType");
4193}
4194
4195static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeOfStringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4196{
4197 UNUSED_PARAM(state);
4198 UNUSED_PARAM(throwScope);
4199 auto& impl = castedThis->wrapped();
4200 if (UNLIKELY(state->argumentCount() < 3))
4201 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4202 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4203 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4204 auto referenceRange = convert<IDLNullable<IDLInterface<Range>>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "referenceRange", "Internals", "rangeOfString", "Range"); });
4205 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4206 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(2));
4207 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4208 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.rangeOfString(WTFMove(text), WTFMove(referenceRange), WTFMove(findOptions))));
4209}
4210
4211EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfString(ExecState* state)
4212{
4213 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeOfStringBody>(*state, "rangeOfString");
4214}
4215
4216static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCountMatchesForTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4217{
4218 UNUSED_PARAM(state);
4219 UNUSED_PARAM(throwScope);
4220 auto& impl = castedThis->wrapped();
4221 if (UNLIKELY(state->argumentCount() < 3))
4222 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4223 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4224 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4225 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(1));
4226 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4227 auto markMatches = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
4228 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4229 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.countMatchesForText(WTFMove(text), WTFMove(findOptions), WTFMove(markMatches))));
4230}
4231
4232EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountMatchesForText(ExecState* state)
4233{
4234 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCountMatchesForTextBody>(*state, "countMatchesForText");
4235}
4236
4237static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCountFindMatchesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4238{
4239 UNUSED_PARAM(state);
4240 UNUSED_PARAM(throwScope);
4241 auto& impl = castedThis->wrapped();
4242 if (UNLIKELY(state->argumentCount() < 2))
4243 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4244 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4245 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4246 auto findOptions = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(1));
4247 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4248 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.countFindMatches(WTFMove(text), WTFMove(findOptions))));
4249}
4250
4251EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCountFindMatches(ExecState* state)
4252{
4253 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCountFindMatchesBody>(*state, "countFindMatches");
4254}
4255
4256static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAutofillFieldNameBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4257{
4258 UNUSED_PARAM(state);
4259 UNUSED_PARAM(throwScope);
4260 auto& impl = castedThis->wrapped();
4261 if (UNLIKELY(state->argumentCount() < 1))
4262 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4263 auto formControlElement = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "formControlElement", "Internals", "autofillFieldName", "Element"); });
4264 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4265 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.autofillFieldName(*formControlElement)));
4266}
4267
4268EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAutofillFieldName(ExecState* state)
4269{
4270 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAutofillFieldNameBody>(*state, "autofillFieldName");
4271}
4272
4273static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInvalidateControlTintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4274{
4275 UNUSED_PARAM(state);
4276 UNUSED_PARAM(throwScope);
4277 auto& impl = castedThis->wrapped();
4278 propagateException(*state, throwScope, impl.invalidateControlTints());
4279 return JSValue::encode(jsUndefined());
4280}
4281
4282EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInvalidateControlTints(ExecState* state)
4283{
4284 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInvalidateControlTintsBody>(*state, "invalidateControlTints");
4285}
4286
4287static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollElementToRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4288{
4289 UNUSED_PARAM(state);
4290 UNUSED_PARAM(throwScope);
4291 auto& impl = castedThis->wrapped();
4292 if (UNLIKELY(state->argumentCount() < 5))
4293 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4294 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "scrollElementToRect", "Element"); });
4295 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4296 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
4297 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4298 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
4299 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4300 auto w = convert<IDLLong>(*state, state->uncheckedArgument(3));
4301 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4302 auto h = convert<IDLLong>(*state, state->uncheckedArgument(4));
4303 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4304 propagateException(*state, throwScope, impl.scrollElementToRect(*element, WTFMove(x), WTFMove(y), WTFMove(w), WTFMove(h)));
4305 return JSValue::encode(jsUndefined());
4306}
4307
4308EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollElementToRect(ExecState* state)
4309{
4310 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollElementToRectBody>(*state, "scrollElementToRect");
4311}
4312
4313static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeFromLocationAndLengthBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4314{
4315 UNUSED_PARAM(state);
4316 UNUSED_PARAM(throwScope);
4317 auto& impl = castedThis->wrapped();
4318 if (UNLIKELY(state->argumentCount() < 3))
4319 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4320 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "rangeFromLocationAndLength", "Element"); });
4321 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4322 auto rangeLocation = convert<IDLLong>(*state, state->uncheckedArgument(1));
4323 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4324 auto rangeLength = convert<IDLLong>(*state, state->uncheckedArgument(2));
4325 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4326 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), impl.rangeFromLocationAndLength(*scope, WTFMove(rangeLocation), WTFMove(rangeLength))));
4327}
4328
4329EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeFromLocationAndLength(ExecState* state)
4330{
4331 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeFromLocationAndLengthBody>(*state, "rangeFromLocationAndLength");
4332}
4333
4334static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLocationFromRangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4335{
4336 UNUSED_PARAM(state);
4337 UNUSED_PARAM(throwScope);
4338 auto& impl = castedThis->wrapped();
4339 if (UNLIKELY(state->argumentCount() < 2))
4340 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4341 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "locationFromRange", "Element"); });
4342 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4343 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "range", "Internals", "locationFromRange", "Range"); });
4344 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4345 return JSValue::encode(toJS<IDLUnsignedLong>(impl.locationFromRange(*scope, *range)));
4346}
4347
4348EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLocationFromRange(ExecState* state)
4349{
4350 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLocationFromRangeBody>(*state, "locationFromRange");
4351}
4352
4353static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLengthFromRangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4354{
4355 UNUSED_PARAM(state);
4356 UNUSED_PARAM(throwScope);
4357 auto& impl = castedThis->wrapped();
4358 if (UNLIKELY(state->argumentCount() < 2))
4359 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4360 auto scope = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "scope", "Internals", "lengthFromRange", "Element"); });
4361 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4362 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "range", "Internals", "lengthFromRange", "Range"); });
4363 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4364 return JSValue::encode(toJS<IDLUnsignedLong>(impl.lengthFromRange(*scope, *range)));
4365}
4366
4367EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLengthFromRange(ExecState* state)
4368{
4369 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLengthFromRangeBody>(*state, "lengthFromRange");
4370}
4371
4372static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4373{
4374 UNUSED_PARAM(state);
4375 UNUSED_PARAM(throwScope);
4376 auto& impl = castedThis->wrapped();
4377 if (UNLIKELY(state->argumentCount() < 1))
4378 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4379 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeAsText", "Range"); });
4380 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4381 return JSValue::encode(toJS<IDLDOMString>(*state, impl.rangeAsText(*range)));
4382}
4383
4384EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsText(ExecState* state)
4385{
4386 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeAsTextBody>(*state, "rangeAsText");
4387}
4388
4389static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIteratorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4390{
4391 UNUSED_PARAM(state);
4392 UNUSED_PARAM(throwScope);
4393 auto& impl = castedThis->wrapped();
4394 if (UNLIKELY(state->argumentCount() < 1))
4395 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4396 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeAsTextUsingBackwardsTextIterator", "Range"); });
4397 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4398 return JSValue::encode(toJS<IDLDOMString>(*state, impl.rangeAsTextUsingBackwardsTextIterator(*range)));
4399}
4400
4401EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIterator(ExecState* state)
4402{
4403 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeAsTextUsingBackwardsTextIteratorBody>(*state, "rangeAsTextUsingBackwardsTextIterator");
4404}
4405
4406static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSubrangeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4407{
4408 UNUSED_PARAM(state);
4409 UNUSED_PARAM(throwScope);
4410 auto& impl = castedThis->wrapped();
4411 if (UNLIKELY(state->argumentCount() < 3))
4412 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4413 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "subrange", "Range"); });
4414 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4415 auto rangeLocation = convert<IDLLong>(*state, state->uncheckedArgument(1));
4416 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4417 auto rangeLength = convert<IDLLong>(*state, state->uncheckedArgument(2));
4418 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4419 return JSValue::encode(toJS<IDLInterface<Range>>(*state, *castedThis->globalObject(), impl.subrange(*range, WTFMove(rangeLocation), WTFMove(rangeLength))));
4420}
4421
4422EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSubrange(ExecState* state)
4423{
4424 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSubrangeBody>(*state, "subrange");
4425}
4426
4427static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4428{
4429 UNUSED_PARAM(state);
4430 UNUSED_PARAM(throwScope);
4431 auto& impl = castedThis->wrapped();
4432 if (UNLIKELY(state->argumentCount() < 2))
4433 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4434 auto x = convert<IDLLong>(*state, state->uncheckedArgument(0));
4435 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4436 auto y = convert<IDLLong>(*state, state->uncheckedArgument(1));
4437 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4438 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), throwScope, impl.rangeForDictionaryLookupAtLocation(WTFMove(x), WTFMove(y))));
4439}
4440
4441EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocation(ExecState* state)
4442{
4443 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeForDictionaryLookupAtLocationBody>(*state, "rangeForDictionaryLookupAtLocation");
4444}
4445
4446static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRangeOfStringNearLocationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4447{
4448 UNUSED_PARAM(state);
4449 UNUSED_PARAM(throwScope);
4450 auto& impl = castedThis->wrapped();
4451 if (UNLIKELY(state->argumentCount() < 3))
4452 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4453 auto range = convert<IDLInterface<Range>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "range", "Internals", "rangeOfStringNearLocation", "Range"); });
4454 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4455 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
4456 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4457 auto targetOffset = convert<IDLLong>(*state, state->uncheckedArgument(2));
4458 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4459 return JSValue::encode(toJS<IDLNullable<IDLInterface<Range>>>(*state, *castedThis->globalObject(), impl.rangeOfStringNearLocation(*range, WTFMove(text), WTFMove(targetOffset))));
4460}
4461
4462EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRangeOfStringNearLocation(ExecState* state)
4463{
4464 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRangeOfStringNearLocationBody>(*state, "rangeOfStringNearLocation");
4465}
4466
4467static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetDelegatesScrollingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4468{
4469 UNUSED_PARAM(state);
4470 UNUSED_PARAM(throwScope);
4471 auto& impl = castedThis->wrapped();
4472 if (UNLIKELY(state->argumentCount() < 1))
4473 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4474 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4475 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4476 propagateException(*state, throwScope, impl.setDelegatesScrolling(WTFMove(enabled)));
4477 return JSValue::encode(jsUndefined());
4478}
4479
4480EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDelegatesScrolling(ExecState* state)
4481{
4482 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetDelegatesScrollingBody>(*state, "setDelegatesScrolling");
4483}
4484
4485static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpellCheckRequestSequenceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4486{
4487 UNUSED_PARAM(state);
4488 UNUSED_PARAM(throwScope);
4489 auto& impl = castedThis->wrapped();
4490 return JSValue::encode(toJS<IDLLong>(*state, throwScope, impl.lastSpellCheckRequestSequence()));
4491}
4492
4493EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckRequestSequence(ExecState* state)
4494{
4495 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpellCheckRequestSequenceBody>(*state, "lastSpellCheckRequestSequence");
4496}
4497
4498static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastSpellCheckProcessedSequenceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4499{
4500 UNUSED_PARAM(state);
4501 UNUSED_PARAM(throwScope);
4502 auto& impl = castedThis->wrapped();
4503 return JSValue::encode(toJS<IDLLong>(*state, throwScope, impl.lastSpellCheckProcessedSequence()));
4504}
4505
4506EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastSpellCheckProcessedSequence(ExecState* state)
4507{
4508 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastSpellCheckProcessedSequenceBody>(*state, "lastSpellCheckProcessedSequence");
4509}
4510
4511static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPreferredLanguagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4512{
4513 UNUSED_PARAM(state);
4514 UNUSED_PARAM(throwScope);
4515 auto& impl = castedThis->wrapped();
4516 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.userPreferredLanguages()));
4517}
4518
4519EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredLanguages(ExecState* state)
4520{
4521 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPreferredLanguagesBody>(*state, "userPreferredLanguages");
4522}
4523
4524static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserPreferredLanguagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4525{
4526 UNUSED_PARAM(state);
4527 UNUSED_PARAM(throwScope);
4528 auto& impl = castedThis->wrapped();
4529 if (UNLIKELY(state->argumentCount() < 1))
4530 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4531 auto languages = convert<IDLSequence<IDLDOMString>>(*state, state->uncheckedArgument(0));
4532 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4533 impl.setUserPreferredLanguages(WTFMove(languages));
4534 return JSValue::encode(jsUndefined());
4535}
4536
4537EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredLanguages(ExecState* state)
4538{
4539 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserPreferredLanguagesBody>(*state, "setUserPreferredLanguages");
4540}
4541
4542static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPreferredAudioCharacteristicsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4543{
4544 UNUSED_PARAM(state);
4545 UNUSED_PARAM(throwScope);
4546 auto& impl = castedThis->wrapped();
4547 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.userPreferredAudioCharacteristics()));
4548}
4549
4550EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPreferredAudioCharacteristics(ExecState* state)
4551{
4552 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPreferredAudioCharacteristicsBody>(*state, "userPreferredAudioCharacteristics");
4553}
4554
4555static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristicBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4556{
4557 UNUSED_PARAM(state);
4558 UNUSED_PARAM(throwScope);
4559 auto& impl = castedThis->wrapped();
4560 if (UNLIKELY(state->argumentCount() < 1))
4561 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4562 auto characteristic = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4563 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4564 impl.setUserPreferredAudioCharacteristic(WTFMove(characteristic));
4565 return JSValue::encode(jsUndefined());
4566}
4567
4568EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristic(ExecState* state)
4569{
4570 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserPreferredAudioCharacteristicBody>(*state, "setUserPreferredAudioCharacteristic");
4571}
4572
4573static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWheelEventHandlerCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4574{
4575 UNUSED_PARAM(state);
4576 UNUSED_PARAM(throwScope);
4577 auto& impl = castedThis->wrapped();
4578 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.wheelEventHandlerCount()));
4579}
4580
4581EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWheelEventHandlerCount(ExecState* state)
4582{
4583 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWheelEventHandlerCountBody>(*state, "wheelEventHandlerCount");
4584}
4585
4586static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTouchEventHandlerCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4587{
4588 UNUSED_PARAM(state);
4589 UNUSED_PARAM(throwScope);
4590 auto& impl = castedThis->wrapped();
4591 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.touchEventHandlerCount()));
4592}
4593
4594EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventHandlerCount(ExecState* state)
4595{
4596 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTouchEventHandlerCountBody>(*state, "touchEventHandlerCount");
4597}
4598
4599static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTouchEventRectsForEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4600{
4601 UNUSED_PARAM(state);
4602 UNUSED_PARAM(throwScope);
4603 auto& impl = castedThis->wrapped();
4604 if (UNLIKELY(state->argumentCount() < 1))
4605 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4606 auto eventName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4607 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4608 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.touchEventRectsForEvent(WTFMove(eventName))));
4609}
4610
4611EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTouchEventRectsForEvent(ExecState* state)
4612{
4613 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTouchEventRectsForEventBody>(*state, "touchEventRectsForEvent");
4614}
4615
4616static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPassiveTouchEventListenerRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4617{
4618 UNUSED_PARAM(state);
4619 UNUSED_PARAM(throwScope);
4620 auto& impl = castedThis->wrapped();
4621 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.passiveTouchEventListenerRects()));
4622}
4623
4624EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPassiveTouchEventListenerRects(ExecState* state)
4625{
4626 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPassiveTouchEventListenerRectsBody>(*state, "passiveTouchEventListenerRects");
4627}
4628
4629static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNodesFromRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4630{
4631 UNUSED_PARAM(state);
4632 UNUSED_PARAM(throwScope);
4633 auto& impl = castedThis->wrapped();
4634 if (UNLIKELY(state->argumentCount() < 10))
4635 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4636 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "nodesFromRect", "Document"); });
4637 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4638 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
4639 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4640 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
4641 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4642 auto topPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(3));
4643 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4644 auto rightPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(4));
4645 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4646 auto bottomPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(5));
4647 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4648 auto leftPadding = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(6));
4649 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4650 auto ignoreClipping = convert<IDLBoolean>(*state, state->uncheckedArgument(7));
4651 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4652 auto allowShadowContent = convert<IDLBoolean>(*state, state->uncheckedArgument(8));
4653 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4654 auto allowChildFrameContent = convert<IDLBoolean>(*state, state->uncheckedArgument(9));
4655 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4656 return JSValue::encode(toJS<IDLNullable<IDLInterface<NodeList>>>(*state, *castedThis->globalObject(), throwScope, impl.nodesFromRect(*document, WTFMove(x), WTFMove(y), WTFMove(topPadding), WTFMove(rightPadding), WTFMove(bottomPadding), WTFMove(leftPadding), WTFMove(ignoreClipping), WTFMove(allowShadowContent), WTFMove(allowChildFrameContent))));
4657}
4658
4659EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNodesFromRect(ExecState* state)
4660{
4661 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNodesFromRectBody>(*state, "nodesFromRect");
4662}
4663
4664static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParserMetaDataBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4665{
4666 UNUSED_PARAM(state);
4667 UNUSED_PARAM(throwScope);
4668 auto& impl = castedThis->wrapped();
4669 auto func = convert<IDLAny>(*state, state->argument(0));
4670 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4671 return JSValue::encode(toJS<IDLDOMString>(*state, impl.parserMetaData(WTFMove(func))));
4672}
4673
4674EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParserMetaData(ExecState* state)
4675{
4676 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParserMetaDataBody>(*state, "parserMetaData");
4677}
4678
4679static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4680{
4681 UNUSED_PARAM(state);
4682 UNUSED_PARAM(throwScope);
4683 auto& impl = castedThis->wrapped();
4684 impl.updateEditorUINowIfScheduled();
4685 return JSValue::encode(jsUndefined());
4686}
4687
4688EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduled(ExecState* state)
4689{
4690 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateEditorUINowIfScheduledBody>(*state, "updateEditorUINowIfScheduled");
4691}
4692
4693static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasSpellingMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4694{
4695 UNUSED_PARAM(state);
4696 UNUSED_PARAM(throwScope);
4697 auto& impl = castedThis->wrapped();
4698 if (UNLIKELY(state->argumentCount() < 2))
4699 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4700 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4701 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4702 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4703 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4704 return JSValue::encode(toJS<IDLBoolean>(impl.hasSpellingMarker(WTFMove(from), WTFMove(length))));
4705}
4706
4707EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasSpellingMarker(ExecState* state)
4708{
4709 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasSpellingMarkerBody>(*state, "hasSpellingMarker");
4710}
4711
4712static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasGrammarMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4713{
4714 UNUSED_PARAM(state);
4715 UNUSED_PARAM(throwScope);
4716 auto& impl = castedThis->wrapped();
4717 if (UNLIKELY(state->argumentCount() < 2))
4718 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4719 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4720 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4721 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4722 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4723 return JSValue::encode(toJS<IDLBoolean>(impl.hasGrammarMarker(WTFMove(from), WTFMove(length))));
4724}
4725
4726EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasGrammarMarker(ExecState* state)
4727{
4728 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasGrammarMarkerBody>(*state, "hasGrammarMarker");
4729}
4730
4731static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasAutocorrectedMarkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4732{
4733 UNUSED_PARAM(state);
4734 UNUSED_PARAM(throwScope);
4735 auto& impl = castedThis->wrapped();
4736 if (UNLIKELY(state->argumentCount() < 2))
4737 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4738 auto from = convert<IDLLong>(*state, state->uncheckedArgument(0));
4739 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4740 auto length = convert<IDLLong>(*state, state->uncheckedArgument(1));
4741 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4742 return JSValue::encode(toJS<IDLBoolean>(impl.hasAutocorrectedMarker(WTFMove(from), WTFMove(length))));
4743}
4744
4745EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasAutocorrectedMarker(ExecState* state)
4746{
4747 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasAutocorrectedMarkerBody>(*state, "hasAutocorrectedMarker");
4748}
4749
4750static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4751{
4752 UNUSED_PARAM(state);
4753 UNUSED_PARAM(throwScope);
4754 auto& impl = castedThis->wrapped();
4755 if (UNLIKELY(state->argumentCount() < 1))
4756 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4757 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4758 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4759 impl.setContinuousSpellCheckingEnabled(WTFMove(enabled));
4760 return JSValue::encode(jsUndefined());
4761}
4762
4763EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabled(ExecState* state)
4764{
4765 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetContinuousSpellCheckingEnabledBody>(*state, "setContinuousSpellCheckingEnabled");
4766}
4767
4768static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4769{
4770 UNUSED_PARAM(state);
4771 UNUSED_PARAM(throwScope);
4772 auto& impl = castedThis->wrapped();
4773 if (UNLIKELY(state->argumentCount() < 1))
4774 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4775 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4776 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4777 impl.setAutomaticQuoteSubstitutionEnabled(WTFMove(enabled));
4778 return JSValue::encode(jsUndefined());
4779}
4780
4781EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabled(ExecState* state)
4782{
4783 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticQuoteSubstitutionEnabledBody>(*state, "setAutomaticQuoteSubstitutionEnabled");
4784}
4785
4786static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4787{
4788 UNUSED_PARAM(state);
4789 UNUSED_PARAM(throwScope);
4790 auto& impl = castedThis->wrapped();
4791 if (UNLIKELY(state->argumentCount() < 1))
4792 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4793 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4794 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4795 impl.setAutomaticLinkDetectionEnabled(WTFMove(enabled));
4796 return JSValue::encode(jsUndefined());
4797}
4798
4799EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabled(ExecState* state)
4800{
4801 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticLinkDetectionEnabledBody>(*state, "setAutomaticLinkDetectionEnabled");
4802}
4803
4804static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4805{
4806 UNUSED_PARAM(state);
4807 UNUSED_PARAM(throwScope);
4808 auto& impl = castedThis->wrapped();
4809 if (UNLIKELY(state->argumentCount() < 1))
4810 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4811 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4812 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4813 impl.setAutomaticDashSubstitutionEnabled(WTFMove(enabled));
4814 return JSValue::encode(jsUndefined());
4815}
4816
4817EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabled(ExecState* state)
4818{
4819 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticDashSubstitutionEnabledBody>(*state, "setAutomaticDashSubstitutionEnabled");
4820}
4821
4822static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4823{
4824 UNUSED_PARAM(state);
4825 UNUSED_PARAM(throwScope);
4826 auto& impl = castedThis->wrapped();
4827 if (UNLIKELY(state->argumentCount() < 1))
4828 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4829 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4830 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4831 impl.setAutomaticTextReplacementEnabled(WTFMove(enabled));
4832 return JSValue::encode(jsUndefined());
4833}
4834
4835EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabled(ExecState* state)
4836{
4837 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticTextReplacementEnabledBody>(*state, "setAutomaticTextReplacementEnabled");
4838}
4839
4840static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4841{
4842 UNUSED_PARAM(state);
4843 UNUSED_PARAM(throwScope);
4844 auto& impl = castedThis->wrapped();
4845 if (UNLIKELY(state->argumentCount() < 1))
4846 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4847 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
4848 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4849 impl.setAutomaticSpellingCorrectionEnabled(WTFMove(enabled));
4850 return JSValue::encode(jsUndefined());
4851}
4852
4853EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabled(ExecState* state)
4854{
4855 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAutomaticSpellingCorrectionEnabledBody>(*state, "setAutomaticSpellingCorrectionEnabled");
4856}
4857
4858static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHandleAcceptedCandidateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4859{
4860 UNUSED_PARAM(state);
4861 UNUSED_PARAM(throwScope);
4862 auto& impl = castedThis->wrapped();
4863 if (UNLIKELY(state->argumentCount() < 3))
4864 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4865 auto candidate = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
4866 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4867 auto location = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
4868 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4869 auto length = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(2));
4870 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4871 impl.handleAcceptedCandidate(WTFMove(candidate), WTFMove(location), WTFMove(length));
4872 return JSValue::encode(jsUndefined());
4873}
4874
4875EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHandleAcceptedCandidate(ExecState* state)
4876{
4877 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHandleAcceptedCandidateBody>(*state, "handleAcceptedCandidate");
4878}
4879
4880static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionChangeSelectionListTypeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4881{
4882 UNUSED_PARAM(state);
4883 UNUSED_PARAM(throwScope);
4884 auto& impl = castedThis->wrapped();
4885 impl.changeSelectionListType();
4886 return JSValue::encode(jsUndefined());
4887}
4888
4889EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionChangeSelectionListType(ExecState* state)
4890{
4891 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionChangeSelectionListTypeBody>(*state, "changeSelectionListType");
4892}
4893
4894static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsOverwriteModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4895{
4896 UNUSED_PARAM(state);
4897 UNUSED_PARAM(throwScope);
4898 auto& impl = castedThis->wrapped();
4899 return JSValue::encode(toJS<IDLBoolean>(impl.isOverwriteModeEnabled()));
4900}
4901
4902EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsOverwriteModeEnabled(ExecState* state)
4903{
4904 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsOverwriteModeEnabledBody>(*state, "isOverwriteModeEnabled");
4905}
4906
4907static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionToggleOverwriteModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4908{
4909 UNUSED_PARAM(state);
4910 UNUSED_PARAM(throwScope);
4911 auto& impl = castedThis->wrapped();
4912 impl.toggleOverwriteModeEnabled();
4913 return JSValue::encode(jsUndefined());
4914}
4915
4916EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToggleOverwriteModeEnabled(ExecState* state)
4917{
4918 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionToggleOverwriteModeEnabledBody>(*state, "toggleOverwriteModeEnabled");
4919}
4920
4921static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfScrollableAreasBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4922{
4923 UNUSED_PARAM(state);
4924 UNUSED_PARAM(throwScope);
4925 auto& impl = castedThis->wrapped();
4926 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfScrollableAreas()));
4927}
4928
4929EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfScrollableAreas(ExecState* state)
4930{
4931 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfScrollableAreasBody>(*state, "numberOfScrollableAreas");
4932}
4933
4934static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPageBoxVisibleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4935{
4936 UNUSED_PARAM(state);
4937 UNUSED_PARAM(throwScope);
4938 auto& impl = castedThis->wrapped();
4939 if (UNLIKELY(state->argumentCount() < 1))
4940 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4941 auto pageNumber = convert<IDLLong>(*state, state->uncheckedArgument(0));
4942 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4943 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isPageBoxVisible(WTFMove(pageNumber))));
4944}
4945
4946EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPageBoxVisible(ExecState* state)
4947{
4948 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPageBoxVisibleBody>(*state, "isPageBoxVisible");
4949}
4950
4951static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameIndexBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4952{
4953 UNUSED_PARAM(state);
4954 UNUSED_PARAM(throwScope);
4955 auto& impl = castedThis->wrapped();
4956 if (UNLIKELY(state->argumentCount() < 1))
4957 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4958 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameIndex", "HTMLImageElement"); });
4959 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4960 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageFrameIndex(*element)));
4961}
4962
4963EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameIndex(ExecState* state)
4964{
4965 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameIndexBody>(*state, "imageFrameIndex");
4966}
4967
4968static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4969{
4970 UNUSED_PARAM(state);
4971 UNUSED_PARAM(throwScope);
4972 auto& impl = castedThis->wrapped();
4973 if (UNLIKELY(state->argumentCount() < 1))
4974 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4975 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameCount", "HTMLImageElement"); });
4976 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4977 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageFrameCount(*element)));
4978}
4979
4980EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameCount(ExecState* state)
4981{
4982 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameCountBody>(*state, "imageFrameCount");
4983}
4984
4985static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageFrameDurationAtIndexBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
4986{
4987 UNUSED_PARAM(state);
4988 UNUSED_PARAM(throwScope);
4989 auto& impl = castedThis->wrapped();
4990 if (UNLIKELY(state->argumentCount() < 2))
4991 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
4992 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageFrameDurationAtIndex", "HTMLImageElement"); });
4993 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4994 auto index = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
4995 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
4996 return JSValue::encode(toJS<IDLFloat>(impl.imageFrameDurationAtIndex(*element, WTFMove(index))));
4997}
4998
4999EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageFrameDurationAtIndex(ExecState* state)
5000{
5001 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageFrameDurationAtIndexBody>(*state, "imageFrameDurationAtIndex");
5002}
5003
5004static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetImageFrameDecodingDurationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5005{
5006 UNUSED_PARAM(state);
5007 UNUSED_PARAM(throwScope);
5008 auto& impl = castedThis->wrapped();
5009 if (UNLIKELY(state->argumentCount() < 2))
5010 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5011 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setImageFrameDecodingDuration", "HTMLImageElement"); });
5012 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5013 auto duration = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5014 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5015 impl.setImageFrameDecodingDuration(*element, WTFMove(duration));
5016 return JSValue::encode(jsUndefined());
5017}
5018
5019EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetImageFrameDecodingDuration(ExecState* state)
5020{
5021 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetImageFrameDecodingDurationBody>(*state, "setImageFrameDecodingDuration");
5022}
5023
5024static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResetImageAnimationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5025{
5026 UNUSED_PARAM(state);
5027 UNUSED_PARAM(throwScope);
5028 auto& impl = castedThis->wrapped();
5029 if (UNLIKELY(state->argumentCount() < 1))
5030 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5031 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "resetImageAnimation", "HTMLImageElement"); });
5032 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5033 impl.resetImageAnimation(*element);
5034 return JSValue::encode(jsUndefined());
5035}
5036
5037EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResetImageAnimation(ExecState* state)
5038{
5039 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResetImageAnimationBody>(*state, "resetImageAnimation");
5040}
5041
5042static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsImageAnimatingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5043{
5044 UNUSED_PARAM(state);
5045 UNUSED_PARAM(throwScope);
5046 auto& impl = castedThis->wrapped();
5047 if (UNLIKELY(state->argumentCount() < 1))
5048 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5049 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isImageAnimating", "HTMLImageElement"); });
5050 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5051 return JSValue::encode(toJS<IDLBoolean>(impl.isImageAnimating(*element)));
5052}
5053
5054EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsImageAnimating(ExecState* state)
5055{
5056 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsImageAnimatingBody>(*state, "isImageAnimating");
5057}
5058
5059static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5060{
5061 UNUSED_PARAM(state);
5062 UNUSED_PARAM(throwScope);
5063 auto& impl = castedThis->wrapped();
5064 if (UNLIKELY(state->argumentCount() < 2))
5065 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5066 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setClearDecoderAfterAsyncFrameRequestForTesting", "HTMLImageElement"); });
5067 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5068 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5069 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5070 impl.setClearDecoderAfterAsyncFrameRequestForTesting(*element, WTFMove(enabled));
5071 return JSValue::encode(jsUndefined());
5072}
5073
5074EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTesting(ExecState* state)
5075{
5076 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetClearDecoderAfterAsyncFrameRequestForTestingBody>(*state, "setClearDecoderAfterAsyncFrameRequestForTesting");
5077}
5078
5079static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionImageDecodeCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5080{
5081 UNUSED_PARAM(state);
5082 UNUSED_PARAM(throwScope);
5083 auto& impl = castedThis->wrapped();
5084 if (UNLIKELY(state->argumentCount() < 1))
5085 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5086 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "imageDecodeCount", "HTMLImageElement"); });
5087 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5088 return JSValue::encode(toJS<IDLUnsignedLong>(impl.imageDecodeCount(*element)));
5089}
5090
5091EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionImageDecodeCount(ExecState* state)
5092{
5093 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionImageDecodeCountBody>(*state, "imageDecodeCount");
5094}
5095
5096static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPdfDocumentCachingCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5097{
5098 UNUSED_PARAM(state);
5099 UNUSED_PARAM(throwScope);
5100 auto& impl = castedThis->wrapped();
5101 if (UNLIKELY(state->argumentCount() < 1))
5102 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5103 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pdfDocumentCachingCount", "HTMLImageElement"); });
5104 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5105 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pdfDocumentCachingCount(*element)));
5106}
5107
5108EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPdfDocumentCachingCount(ExecState* state)
5109{
5110 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPdfDocumentCachingCountBody>(*state, "pdfDocumentCachingCount");
5111}
5112
5113static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5114{
5115 UNUSED_PARAM(state);
5116 UNUSED_PARAM(throwScope);
5117 auto& impl = castedThis->wrapped();
5118 if (UNLIKELY(state->argumentCount() < 2))
5119 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5120 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setLargeImageAsyncDecodingEnabledForTesting", "HTMLImageElement"); });
5121 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5122 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5123 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5124 impl.setLargeImageAsyncDecodingEnabledForTesting(*element, WTFMove(enabled));
5125 return JSValue::encode(jsUndefined());
5126}
5127
5128EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTesting(ExecState* state)
5129{
5130 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetLargeImageAsyncDecodingEnabledForTestingBody>(*state, "setLargeImageAsyncDecodingEnabledForTesting");
5131}
5132
5133static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5134{
5135 UNUSED_PARAM(state);
5136 UNUSED_PARAM(throwScope);
5137 auto& impl = castedThis->wrapped();
5138 if (UNLIKELY(state->argumentCount() < 2))
5139 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5140 auto element = convert<IDLInterface<HTMLImageElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setForceUpdateImageDataEnabledForTesting", "HTMLImageElement"); });
5141 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5142 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5143 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5144 impl.setForceUpdateImageDataEnabledForTesting(*element, WTFMove(enabled));
5145 return JSValue::encode(jsUndefined());
5146}
5147
5148EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTesting(ExecState* state)
5149{
5150 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetForceUpdateImageDataEnabledForTestingBody>(*state, "setForceUpdateImageDataEnabledForTesting");
5151}
5152
5153static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetGridMaxTracksLimitBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5154{
5155 UNUSED_PARAM(state);
5156 UNUSED_PARAM(throwScope);
5157 auto& impl = castedThis->wrapped();
5158 if (UNLIKELY(state->argumentCount() < 1))
5159 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5160 auto maxTracksLimit = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(0));
5161 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5162 impl.setGridMaxTracksLimit(WTFMove(maxTracksLimit));
5163 return JSValue::encode(jsUndefined());
5164}
5165
5166EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetGridMaxTracksLimit(ExecState* state)
5167{
5168 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetGridMaxTracksLimitBody>(*state, "setGridMaxTracksLimit");
5169}
5170
5171static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSVGAnimationsIntervalBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5172{
5173 UNUSED_PARAM(state);
5174 UNUSED_PARAM(throwScope);
5175 auto& impl = castedThis->wrapped();
5176 if (UNLIKELY(state->argumentCount() < 1))
5177 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5178 auto element = convert<IDLInterface<SVGSVGElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "svgAnimationsInterval", "SVGSVGElement"); });
5179 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5180 return JSValue::encode(toJS<IDLDouble>(*state, throwScope, impl.svgAnimationsInterval(*element)));
5181}
5182
5183EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSVGAnimationsInterval(ExecState* state)
5184{
5185 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSVGAnimationsIntervalBody>(*state, "svgAnimationsInterval");
5186}
5187
5188static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5189{
5190 UNUSED_PARAM(state);
5191 UNUSED_PARAM(throwScope);
5192 auto& impl = castedThis->wrapped();
5193 if (UNLIKELY(state->argumentCount() < 1))
5194 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5195 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "layerTreeAsText", "Document"); });
5196 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5197 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5198 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5199 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.layerTreeAsText(*document, WTFMove(flags))));
5200}
5201
5202EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerTreeAsText(ExecState* state)
5203{
5204 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerTreeAsTextBody>(*state, "layerTreeAsText");
5205}
5206
5207static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerIDForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5208{
5209 UNUSED_PARAM(state);
5210 UNUSED_PARAM(throwScope);
5211 auto& impl = castedThis->wrapped();
5212 if (UNLIKELY(state->argumentCount() < 1))
5213 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5214 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "layerIDForElement", "Element"); });
5215 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5216 return JSValue::encode(toJS<IDLUnsignedLongLong>(*state, throwScope, impl.layerIDForElement(*element)));
5217}
5218
5219EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerIDForElement(ExecState* state)
5220{
5221 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerIDForElementBody>(*state, "layerIDForElement");
5222}
5223
5224static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollbarOverlayStyleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5225{
5226 UNUSED_PARAM(state);
5227 UNUSED_PARAM(throwScope);
5228 auto& impl = castedThis->wrapped();
5229 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "scrollbarOverlayStyle", "Node"); });
5230 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5231 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollbarOverlayStyle(WTFMove(node))));
5232}
5233
5234EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarOverlayStyle(ExecState* state)
5235{
5236 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollbarOverlayStyleBody>(*state, "scrollbarOverlayStyle");
5237}
5238
5239static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollbarUsingDarkAppearanceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5240{
5241 UNUSED_PARAM(state);
5242 UNUSED_PARAM(throwScope);
5243 auto& impl = castedThis->wrapped();
5244 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "scrollbarUsingDarkAppearance", "Node"); });
5245 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5246 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.scrollbarUsingDarkAppearance(WTFMove(node))));
5247}
5248
5249EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollbarUsingDarkAppearance(ExecState* state)
5250{
5251 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollbarUsingDarkAppearanceBody>(*state, "scrollbarUsingDarkAppearance");
5252}
5253
5254static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollingStateTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5255{
5256 UNUSED_PARAM(state);
5257 UNUSED_PARAM(throwScope);
5258 auto& impl = castedThis->wrapped();
5259 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollingStateTreeAsText()));
5260}
5261
5262EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollingStateTreeAsText(ExecState* state)
5263{
5264 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollingStateTreeAsTextBody>(*state, "scrollingStateTreeAsText");
5265}
5266
5267static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMainThreadScrollingReasonsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5268{
5269 UNUSED_PARAM(state);
5270 UNUSED_PARAM(throwScope);
5271 auto& impl = castedThis->wrapped();
5272 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.mainThreadScrollingReasons()));
5273}
5274
5275EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMainThreadScrollingReasons(ExecState* state)
5276{
5277 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMainThreadScrollingReasonsBody>(*state, "mainThreadScrollingReasons");
5278}
5279
5280static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNonFastScrollableRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5281{
5282 UNUSED_PARAM(state);
5283 UNUSED_PARAM(throwScope);
5284 auto& impl = castedThis->wrapped();
5285 return JSValue::encode(toJS<IDLInterface<DOMRectList>>(*state, *castedThis->globalObject(), throwScope, impl.nonFastScrollableRects()));
5286}
5287
5288EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNonFastScrollableRects(ExecState* state)
5289{
5290 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNonFastScrollableRectsBody>(*state, "nonFastScrollableRects");
5291}
5292
5293static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRepaintRectsAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5294{
5295 UNUSED_PARAM(state);
5296 UNUSED_PARAM(throwScope);
5297 auto& impl = castedThis->wrapped();
5298 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.repaintRectsAsText()));
5299}
5300
5301EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRepaintRectsAsText(ExecState* state)
5302{
5303 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRepaintRectsAsTextBody>(*state, "repaintRectsAsText");
5304}
5305
5306static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5307{
5308 UNUSED_PARAM(state);
5309 UNUSED_PARAM(throwScope);
5310 auto& impl = castedThis->wrapped();
5311 if (UNLIKELY(state->argumentCount() < 2))
5312 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5313 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setElementUsesDisplayListDrawing", "Element"); });
5314 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5315 auto usesDisplayListDrawing = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5316 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5317 propagateException(*state, throwScope, impl.setElementUsesDisplayListDrawing(*element, WTFMove(usesDisplayListDrawing)));
5318 return JSValue::encode(jsUndefined());
5319}
5320
5321EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawing(ExecState* state)
5322{
5323 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetElementUsesDisplayListDrawingBody>(*state, "setElementUsesDisplayListDrawing");
5324}
5325
5326static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetElementTracksDisplayListReplayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5327{
5328 UNUSED_PARAM(state);
5329 UNUSED_PARAM(throwScope);
5330 auto& impl = castedThis->wrapped();
5331 if (UNLIKELY(state->argumentCount() < 2))
5332 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5333 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setElementTracksDisplayListReplay", "Element"); });
5334 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5335 auto trackReplay = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
5336 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5337 propagateException(*state, throwScope, impl.setElementTracksDisplayListReplay(*element, WTFMove(trackReplay)));
5338 return JSValue::encode(jsUndefined());
5339}
5340
5341EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetElementTracksDisplayListReplay(ExecState* state)
5342{
5343 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetElementTracksDisplayListReplayBody>(*state, "setElementTracksDisplayListReplay");
5344}
5345
5346static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDisplayListForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5347{
5348 UNUSED_PARAM(state);
5349 UNUSED_PARAM(throwScope);
5350 auto& impl = castedThis->wrapped();
5351 if (UNLIKELY(state->argumentCount() < 1))
5352 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5353 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "displayListForElement", "Element"); });
5354 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5355 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5356 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5357 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.displayListForElement(*element, WTFMove(flags))));
5358}
5359
5360EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisplayListForElement(ExecState* state)
5361{
5362 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDisplayListForElementBody>(*state, "displayListForElement");
5363}
5364
5365static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReplayDisplayListForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5366{
5367 UNUSED_PARAM(state);
5368 UNUSED_PARAM(throwScope);
5369 auto& impl = castedThis->wrapped();
5370 if (UNLIKELY(state->argumentCount() < 1))
5371 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5372 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "replayDisplayListForElement", "Element"); });
5373 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5374 auto flags = convert<IDLUnsignedShort>(*state, state->argument(1));
5375 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5376 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.replayDisplayListForElement(*element, WTFMove(flags))));
5377}
5378
5379EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReplayDisplayListForElement(ExecState* state)
5380{
5381 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReplayDisplayListForElementBody>(*state, "replayDisplayListForElement");
5382}
5383
5384static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGarbageCollectDocumentResourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5385{
5386 UNUSED_PARAM(state);
5387 UNUSED_PARAM(throwScope);
5388 auto& impl = castedThis->wrapped();
5389 propagateException(*state, throwScope, impl.garbageCollectDocumentResources());
5390 return JSValue::encode(jsUndefined());
5391}
5392
5393EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGarbageCollectDocumentResources(ExecState* state)
5394{
5395 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGarbageCollectDocumentResourcesBody>(*state, "garbageCollectDocumentResources");
5396}
5397
5398static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInsertAuthorCSSBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5399{
5400 UNUSED_PARAM(state);
5401 UNUSED_PARAM(throwScope);
5402 auto& impl = castedThis->wrapped();
5403 if (UNLIKELY(state->argumentCount() < 1))
5404 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5405 auto css = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5406 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5407 propagateException(*state, throwScope, impl.insertAuthorCSS(WTFMove(css)));
5408 return JSValue::encode(jsUndefined());
5409}
5410
5411EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertAuthorCSS(ExecState* state)
5412{
5413 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInsertAuthorCSSBody>(*state, "insertAuthorCSS");
5414}
5415
5416static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInsertUserCSSBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5417{
5418 UNUSED_PARAM(state);
5419 UNUSED_PARAM(throwScope);
5420 auto& impl = castedThis->wrapped();
5421 if (UNLIKELY(state->argumentCount() < 1))
5422 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5423 auto css = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5424 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5425 propagateException(*state, throwScope, impl.insertUserCSS(WTFMove(css)));
5426 return JSValue::encode(jsUndefined());
5427}
5428
5429EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInsertUserCSS(ExecState* state)
5430{
5431 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInsertUserCSSBody>(*state, "insertUserCSS");
5432}
5433
5434static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginSimulatedMemoryPressureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5435{
5436 UNUSED_PARAM(state);
5437 UNUSED_PARAM(throwScope);
5438 auto& impl = castedThis->wrapped();
5439 impl.beginSimulatedMemoryPressure();
5440 return JSValue::encode(jsUndefined());
5441}
5442
5443EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedMemoryPressure(ExecState* state)
5444{
5445 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginSimulatedMemoryPressureBody>(*state, "beginSimulatedMemoryPressure");
5446}
5447
5448static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndSimulatedMemoryPressureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5449{
5450 UNUSED_PARAM(state);
5451 UNUSED_PARAM(throwScope);
5452 auto& impl = castedThis->wrapped();
5453 impl.endSimulatedMemoryPressure();
5454 return JSValue::encode(jsUndefined());
5455}
5456
5457EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedMemoryPressure(ExecState* state)
5458{
5459 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndSimulatedMemoryPressureBody>(*state, "endSimulatedMemoryPressure");
5460}
5461
5462static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfIDBTransactionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5463{
5464 UNUSED_PARAM(state);
5465 UNUSED_PARAM(throwScope);
5466 auto& impl = castedThis->wrapped();
5467 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfIDBTransactions()));
5468}
5469
5470EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIDBTransactions(ExecState* state)
5471{
5472 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfIDBTransactionsBody>(*state, "numberOfIDBTransactions");
5473}
5474
5475static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfLiveNodesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5476{
5477 UNUSED_PARAM(state);
5478 UNUSED_PARAM(throwScope);
5479 auto& impl = castedThis->wrapped();
5480 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfLiveNodes()));
5481}
5482
5483EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveNodes(ExecState* state)
5484{
5485 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfLiveNodesBody>(*state, "numberOfLiveNodes");
5486}
5487
5488static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfLiveDocumentsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5489{
5490 UNUSED_PARAM(state);
5491 UNUSED_PARAM(throwScope);
5492 auto& impl = castedThis->wrapped();
5493 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfLiveDocuments()));
5494}
5495
5496EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfLiveDocuments(ExecState* state)
5497{
5498 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfLiveDocumentsBody>(*state, "numberOfLiveDocuments");
5499}
5500
5501static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReferencingNodeCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5502{
5503 UNUSED_PARAM(state);
5504 UNUSED_PARAM(throwScope);
5505 auto& impl = castedThis->wrapped();
5506 if (UNLIKELY(state->argumentCount() < 1))
5507 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5508 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "referencingNodeCount", "Document"); });
5509 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5510 return JSValue::encode(toJS<IDLUnsignedLong>(impl.referencingNodeCount(*document)));
5511}
5512
5513EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReferencingNodeCount(ExecState* state)
5514{
5515 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReferencingNodeCountBody>(*state, "referencingNodeCount");
5516}
5517
5518#if ENABLE(INTERSECTION_OBSERVER)
5519static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfIntersectionObserversBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5520{
5521 UNUSED_PARAM(state);
5522 UNUSED_PARAM(throwScope);
5523 auto& impl = castedThis->wrapped();
5524 if (UNLIKELY(state->argumentCount() < 1))
5525 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5526 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "numberOfIntersectionObservers", "Document"); });
5527 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5528 return JSValue::encode(toJS<IDLUnsignedLong>(impl.numberOfIntersectionObservers(*document)));
5529}
5530
5531EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfIntersectionObservers(ExecState* state)
5532{
5533 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfIntersectionObserversBody>(*state, "numberOfIntersectionObservers");
5534}
5535
5536#endif
5537
5538static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionOpenDummyInspectorFrontendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5539{
5540 UNUSED_PARAM(state);
5541 UNUSED_PARAM(throwScope);
5542 auto& impl = castedThis->wrapped();
5543 if (UNLIKELY(state->argumentCount() < 1))
5544 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5545 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5546 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5547 return JSValue::encode(toJS<IDLNullable<IDLInterface<WindowProxy>>>(*state, *castedThis->globalObject(), impl.openDummyInspectorFrontend(WTFMove(url))));
5548}
5549
5550EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOpenDummyInspectorFrontend(ExecState* state)
5551{
5552 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionOpenDummyInspectorFrontendBody>(*state, "openDummyInspectorFrontend");
5553}
5554
5555static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCloseDummyInspectorFrontendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5556{
5557 UNUSED_PARAM(state);
5558 UNUSED_PARAM(throwScope);
5559 auto& impl = castedThis->wrapped();
5560 impl.closeDummyInspectorFrontend();
5561 return JSValue::encode(jsUndefined());
5562}
5563
5564EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloseDummyInspectorFrontend(ExecState* state)
5565{
5566 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCloseDummyInspectorFrontendBody>(*state, "closeDummyInspectorFrontend");
5567}
5568
5569static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetInspectorIsUnderTestBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5570{
5571 UNUSED_PARAM(state);
5572 UNUSED_PARAM(throwScope);
5573 auto& impl = castedThis->wrapped();
5574 if (UNLIKELY(state->argumentCount() < 1))
5575 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5576 auto isUnderTest = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
5577 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5578 propagateException(*state, throwScope, impl.setInspectorIsUnderTest(WTFMove(isUnderTest)));
5579 return JSValue::encode(jsUndefined());
5580}
5581
5582EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetInspectorIsUnderTest(ExecState* state)
5583{
5584 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetInspectorIsUnderTestBody>(*state, "setInspectorIsUnderTest");
5585}
5586
5587static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCounterValueBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5588{
5589 UNUSED_PARAM(state);
5590 UNUSED_PARAM(throwScope);
5591 auto& impl = castedThis->wrapped();
5592 if (UNLIKELY(state->argumentCount() < 1))
5593 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5594 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "counterValue", "Element"); });
5595 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5596 return JSValue::encode(toJS<IDLDOMString>(*state, impl.counterValue(*element)));
5597}
5598
5599EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCounterValue(ExecState* state)
5600{
5601 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCounterValueBody>(*state, "counterValue");
5602}
5603
5604static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageNumberBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5605{
5606 UNUSED_PARAM(state);
5607 UNUSED_PARAM(throwScope);
5608 auto& impl = castedThis->wrapped();
5609 if (UNLIKELY(state->argumentCount() < 1))
5610 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5611 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pageNumber", "Element"); });
5612 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5613 auto pageWidth = state->argument(1).isUndefined() ? 800 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5614 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5615 auto pageHeight = state->argument(2).isUndefined() ? 600 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(2));
5616 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5617 return JSValue::encode(toJS<IDLLong>(impl.pageNumber(*element, WTFMove(pageWidth), WTFMove(pageHeight))));
5618}
5619
5620EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageNumber(ExecState* state)
5621{
5622 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageNumberBody>(*state, "pageNumber");
5623}
5624
5625static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionShortcutIconURLsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5626{
5627 UNUSED_PARAM(state);
5628 UNUSED_PARAM(throwScope);
5629 auto& impl = castedThis->wrapped();
5630 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.shortcutIconURLs()));
5631}
5632
5633EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionShortcutIconURLs(ExecState* state)
5634{
5635 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionShortcutIconURLsBody>(*state, "shortcutIconURLs");
5636}
5637
5638static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNumberOfPagesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5639{
5640 UNUSED_PARAM(state);
5641 UNUSED_PARAM(throwScope);
5642 auto& impl = castedThis->wrapped();
5643 auto pageWidthInPixels = state->argument(0).isUndefined() ? 800 : convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(0));
5644 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5645 auto pageHeightInPixels = state->argument(1).isUndefined() ? 600 : convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(1));
5646 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5647 return JSValue::encode(toJS<IDLLong>(impl.numberOfPages(WTFMove(pageWidthInPixels), WTFMove(pageHeightInPixels))));
5648}
5649
5650EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNumberOfPages(ExecState* state)
5651{
5652 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNumberOfPagesBody>(*state, "numberOfPages");
5653}
5654
5655static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPagePropertyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5656{
5657 UNUSED_PARAM(state);
5658 UNUSED_PARAM(throwScope);
5659 auto& impl = castedThis->wrapped();
5660 if (UNLIKELY(state->argumentCount() < 2))
5661 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5662 auto propertyName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
5663 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5664 auto pageNumber = convert<IDLLong>(*state, state->uncheckedArgument(1));
5665 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5666 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageProperty(WTFMove(propertyName), WTFMove(pageNumber))));
5667}
5668
5669EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageProperty(ExecState* state)
5670{
5671 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPagePropertyBody>(*state, "pageProperty");
5672}
5673
5674static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageSizeAndMarginsInPixelsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5675{
5676 UNUSED_PARAM(state);
5677 UNUSED_PARAM(throwScope);
5678 auto& impl = castedThis->wrapped();
5679 if (UNLIKELY(state->argumentCount() < 7))
5680 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5681 auto pageIndex = convert<IDLLong>(*state, state->uncheckedArgument(0));
5682 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5683 auto width = convert<IDLLong>(*state, state->uncheckedArgument(1));
5684 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5685 auto height = convert<IDLLong>(*state, state->uncheckedArgument(2));
5686 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5687 auto marginTop = convert<IDLLong>(*state, state->uncheckedArgument(3));
5688 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5689 auto marginRight = convert<IDLLong>(*state, state->uncheckedArgument(4));
5690 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5691 auto marginBottom = convert<IDLLong>(*state, state->uncheckedArgument(5));
5692 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5693 auto marginLeft = convert<IDLLong>(*state, state->uncheckedArgument(6));
5694 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5695 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageSizeAndMarginsInPixels(WTFMove(pageIndex), WTFMove(width), WTFMove(height), WTFMove(marginTop), WTFMove(marginRight), WTFMove(marginBottom), WTFMove(marginLeft))));
5696}
5697
5698EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageSizeAndMarginsInPixels(ExecState* state)
5699{
5700 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageSizeAndMarginsInPixelsBody>(*state, "pageSizeAndMarginsInPixels");
5701}
5702
5703static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageScaleFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5704{
5705 UNUSED_PARAM(state);
5706 UNUSED_PARAM(throwScope);
5707 auto& impl = castedThis->wrapped();
5708 if (UNLIKELY(state->argumentCount() < 3))
5709 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5710 auto scaleFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5711 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5712 auto x = convert<IDLLong>(*state, state->uncheckedArgument(1));
5713 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5714 auto y = convert<IDLLong>(*state, state->uncheckedArgument(2));
5715 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5716 propagateException(*state, throwScope, impl.setPageScaleFactor(WTFMove(scaleFactor), WTFMove(x), WTFMove(y)));
5717 return JSValue::encode(jsUndefined());
5718}
5719
5720EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageScaleFactor(ExecState* state)
5721{
5722 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageScaleFactorBody>(*state, "setPageScaleFactor");
5723}
5724
5725static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageScaleFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5726{
5727 UNUSED_PARAM(state);
5728 UNUSED_PARAM(throwScope);
5729 auto& impl = castedThis->wrapped();
5730 return JSValue::encode(toJS<IDLFloat>(*state, throwScope, impl.pageScaleFactor()));
5731}
5732
5733EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageScaleFactor(ExecState* state)
5734{
5735 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageScaleFactorBody>(*state, "pageScaleFactor");
5736}
5737
5738static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageZoomFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5739{
5740 UNUSED_PARAM(state);
5741 UNUSED_PARAM(throwScope);
5742 auto& impl = castedThis->wrapped();
5743 if (UNLIKELY(state->argumentCount() < 1))
5744 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5745 auto zoomFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5746 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5747 propagateException(*state, throwScope, impl.setPageZoomFactor(WTFMove(zoomFactor)));
5748 return JSValue::encode(jsUndefined());
5749}
5750
5751EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageZoomFactor(ExecState* state)
5752{
5753 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageZoomFactorBody>(*state, "setPageZoomFactor");
5754}
5755
5756static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetTextZoomFactorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5757{
5758 UNUSED_PARAM(state);
5759 UNUSED_PARAM(throwScope);
5760 auto& impl = castedThis->wrapped();
5761 if (UNLIKELY(state->argumentCount() < 1))
5762 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5763 auto zoomFactor = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5764 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5765 propagateException(*state, throwScope, impl.setTextZoomFactor(WTFMove(zoomFactor)));
5766 return JSValue::encode(jsUndefined());
5767}
5768
5769EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTextZoomFactor(ExecState* state)
5770{
5771 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetTextZoomFactorBody>(*state, "setTextZoomFactor");
5772}
5773
5774static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUseFixedLayoutBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5775{
5776 UNUSED_PARAM(state);
5777 UNUSED_PARAM(throwScope);
5778 auto& impl = castedThis->wrapped();
5779 if (UNLIKELY(state->argumentCount() < 1))
5780 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5781 auto useFixedLayout = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
5782 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5783 propagateException(*state, throwScope, impl.setUseFixedLayout(WTFMove(useFixedLayout)));
5784 return JSValue::encode(jsUndefined());
5785}
5786
5787EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseFixedLayout(ExecState* state)
5788{
5789 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUseFixedLayoutBody>(*state, "setUseFixedLayout");
5790}
5791
5792static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFixedLayoutSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5793{
5794 UNUSED_PARAM(state);
5795 UNUSED_PARAM(throwScope);
5796 auto& impl = castedThis->wrapped();
5797 if (UNLIKELY(state->argumentCount() < 2))
5798 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5799 auto width = convert<IDLLong>(*state, state->uncheckedArgument(0));
5800 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5801 auto height = convert<IDLLong>(*state, state->uncheckedArgument(1));
5802 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5803 propagateException(*state, throwScope, impl.setFixedLayoutSize(WTFMove(width), WTFMove(height)));
5804 return JSValue::encode(jsUndefined());
5805}
5806
5807EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFixedLayoutSize(ExecState* state)
5808{
5809 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFixedLayoutSizeBody>(*state, "setFixedLayoutSize");
5810}
5811
5812static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPrintingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5813{
5814 UNUSED_PARAM(state);
5815 UNUSED_PARAM(throwScope);
5816 auto& impl = castedThis->wrapped();
5817 if (UNLIKELY(state->argumentCount() < 2))
5818 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5819 auto width = convert<IDLLong>(*state, state->uncheckedArgument(0));
5820 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5821 auto height = convert<IDLLong>(*state, state->uncheckedArgument(1));
5822 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5823 impl.setPrinting(WTFMove(width), WTFMove(height));
5824 return JSValue::encode(jsUndefined());
5825}
5826
5827EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrinting(ExecState* state)
5828{
5829 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPrintingBody>(*state, "setPrinting");
5830}
5831
5832static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetViewExposedRectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5833{
5834 UNUSED_PARAM(state);
5835 UNUSED_PARAM(throwScope);
5836 auto& impl = castedThis->wrapped();
5837 if (UNLIKELY(state->argumentCount() < 4))
5838 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5839 auto x = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5840 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5841 auto y = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
5842 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5843 auto width = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(2));
5844 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5845 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(3));
5846 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5847 propagateException(*state, throwScope, impl.setViewExposedRect(WTFMove(x), WTFMove(y), WTFMove(width), WTFMove(height)));
5848 return JSValue::encode(jsUndefined());
5849}
5850
5851EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetViewExposedRect(ExecState* state)
5852{
5853 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetViewExposedRectBody>(*state, "setViewExposedRect");
5854}
5855
5856static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetHeaderHeightBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5857{
5858 UNUSED_PARAM(state);
5859 UNUSED_PARAM(throwScope);
5860 auto& impl = castedThis->wrapped();
5861 if (UNLIKELY(state->argumentCount() < 1))
5862 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5863 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5864 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5865 impl.setHeaderHeight(WTFMove(height));
5866 return JSValue::encode(jsUndefined());
5867}
5868
5869EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHeaderHeight(ExecState* state)
5870{
5871 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetHeaderHeightBody>(*state, "setHeaderHeight");
5872}
5873
5874static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFooterHeightBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5875{
5876 UNUSED_PARAM(state);
5877 UNUSED_PARAM(throwScope);
5878 auto& impl = castedThis->wrapped();
5879 if (UNLIKELY(state->argumentCount() < 1))
5880 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5881 auto height = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5882 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5883 impl.setFooterHeight(WTFMove(height));
5884 return JSValue::encode(jsUndefined());
5885}
5886
5887EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFooterHeight(ExecState* state)
5888{
5889 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFooterHeightBody>(*state, "setFooterHeight");
5890}
5891
5892static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetTopContentInsetBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5893{
5894 UNUSED_PARAM(state);
5895 UNUSED_PARAM(throwScope);
5896 auto& impl = castedThis->wrapped();
5897 if (UNLIKELY(state->argumentCount() < 1))
5898 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5899 auto contentInset = convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(0));
5900 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5901 impl.setTopContentInset(WTFMove(contentInset));
5902 return JSValue::encode(jsUndefined());
5903}
5904
5905EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetTopContentInset(ExecState* state)
5906{
5907 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetTopContentInsetBody>(*state, "setTopContentInset");
5908}
5909
5910#if ENABLE(FULLSCREEN_API)
5911static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5912{
5913 UNUSED_PARAM(state);
5914 UNUSED_PARAM(throwScope);
5915 auto& impl = castedThis->wrapped();
5916 if (UNLIKELY(state->argumentCount() < 1))
5917 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5918 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitWillEnterFullScreenForElement", "Element"); });
5919 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5920 impl.webkitWillEnterFullScreenForElement(*element);
5921 return JSValue::encode(jsUndefined());
5922}
5923
5924EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElement(ExecState* state)
5925{
5926 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitWillEnterFullScreenForElementBody>(*state, "webkitWillEnterFullScreenForElement");
5927}
5928
5929#endif
5930
5931#if ENABLE(FULLSCREEN_API)
5932static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5933{
5934 UNUSED_PARAM(state);
5935 UNUSED_PARAM(throwScope);
5936 auto& impl = castedThis->wrapped();
5937 if (UNLIKELY(state->argumentCount() < 1))
5938 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5939 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitDidEnterFullScreenForElement", "Element"); });
5940 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5941 impl.webkitDidEnterFullScreenForElement(*element);
5942 return JSValue::encode(jsUndefined());
5943}
5944
5945EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElement(ExecState* state)
5946{
5947 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitDidEnterFullScreenForElementBody>(*state, "webkitDidEnterFullScreenForElement");
5948}
5949
5950#endif
5951
5952#if ENABLE(FULLSCREEN_API)
5953static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5954{
5955 UNUSED_PARAM(state);
5956 UNUSED_PARAM(throwScope);
5957 auto& impl = castedThis->wrapped();
5958 if (UNLIKELY(state->argumentCount() < 1))
5959 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5960 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitWillExitFullScreenForElement", "Element"); });
5961 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5962 impl.webkitWillExitFullScreenForElement(*element);
5963 return JSValue::encode(jsUndefined());
5964}
5965
5966EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElement(ExecState* state)
5967{
5968 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitWillExitFullScreenForElementBody>(*state, "webkitWillExitFullScreenForElement");
5969}
5970
5971#endif
5972
5973#if ENABLE(FULLSCREEN_API)
5974static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5975{
5976 UNUSED_PARAM(state);
5977 UNUSED_PARAM(throwScope);
5978 auto& impl = castedThis->wrapped();
5979 if (UNLIKELY(state->argumentCount() < 1))
5980 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
5981 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "webkitDidExitFullScreenForElement", "Element"); });
5982 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
5983 impl.webkitDidExitFullScreenForElement(*element);
5984 return JSValue::encode(jsUndefined());
5985}
5986
5987EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElement(ExecState* state)
5988{
5989 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWebkitDidExitFullScreenForElementBody>(*state, "webkitDidExitFullScreenForElement");
5990}
5991
5992#endif
5993
5994static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenInsetsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
5995{
5996 UNUSED_PARAM(state);
5997 UNUSED_PARAM(throwScope);
5998 auto& impl = castedThis->wrapped();
5999 if (UNLIKELY(state->argumentCount() < 1))
6000 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6001 auto insets = convert<IDLDictionary<Internals::FullscreenInsets>>(*state, state->uncheckedArgument(0));
6002 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6003 impl.setFullscreenInsets(WTFMove(insets));
6004 return JSValue::encode(jsUndefined());
6005}
6006
6007EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenInsets(ExecState* state)
6008{
6009 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenInsetsBody>(*state, "setFullscreenInsets");
6010}
6011
6012static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenAutoHideDurationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6013{
6014 UNUSED_PARAM(state);
6015 UNUSED_PARAM(throwScope);
6016 auto& impl = castedThis->wrapped();
6017 if (UNLIKELY(state->argumentCount() < 1))
6018 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6019 auto duration = convert<IDLDouble>(*state, state->uncheckedArgument(0));
6020 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6021 impl.setFullscreenAutoHideDuration(WTFMove(duration));
6022 return JSValue::encode(jsUndefined());
6023}
6024
6025EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenAutoHideDuration(ExecState* state)
6026{
6027 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenAutoHideDurationBody>(*state, "setFullscreenAutoHideDuration");
6028}
6029
6030static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetFullscreenControlsHiddenBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6031{
6032 UNUSED_PARAM(state);
6033 UNUSED_PARAM(throwScope);
6034 auto& impl = castedThis->wrapped();
6035 if (UNLIKELY(state->argumentCount() < 1))
6036 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6037 auto hidden = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6038 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6039 impl.setFullscreenControlsHidden(WTFMove(hidden));
6040 return JSValue::encode(jsUndefined());
6041}
6042
6043EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetFullscreenControlsHidden(ExecState* state)
6044{
6045 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetFullscreenControlsHiddenBody>(*state, "setFullscreenControlsHidden");
6046}
6047
6048static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetApplicationCacheOriginQuotaBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6049{
6050 UNUSED_PARAM(state);
6051 UNUSED_PARAM(throwScope);
6052 auto& impl = castedThis->wrapped();
6053 if (UNLIKELY(state->argumentCount() < 1))
6054 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6055 auto quota = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(0));
6056 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6057 impl.setApplicationCacheOriginQuota(WTFMove(quota));
6058 return JSValue::encode(jsUndefined());
6059}
6060
6061EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetApplicationCacheOriginQuota(ExecState* state)
6062{
6063 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetApplicationCacheOriginQuotaBody>(*state, "setApplicationCacheOriginQuota");
6064}
6065
6066static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6067{
6068 UNUSED_PARAM(state);
6069 UNUSED_PARAM(throwScope);
6070 auto& impl = castedThis->wrapped();
6071 if (UNLIKELY(state->argumentCount() < 1))
6072 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6073 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6074 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6075 impl.registerURLSchemeAsBypassingContentSecurityPolicy(WTFMove(scheme));
6076 return JSValue::encode(jsUndefined());
6077}
6078
6079EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicy(ExecState* state)
6080{
6081 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterURLSchemeAsBypassingContentSecurityPolicyBody>(*state, "registerURLSchemeAsBypassingContentSecurityPolicy");
6082}
6083
6084static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6085{
6086 UNUSED_PARAM(state);
6087 UNUSED_PARAM(throwScope);
6088 auto& impl = castedThis->wrapped();
6089 if (UNLIKELY(state->argumentCount() < 1))
6090 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6091 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6092 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6093 impl.removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(WTFMove(scheme));
6094 return JSValue::encode(jsUndefined());
6095}
6096
6097EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicy(ExecState* state)
6098{
6099 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRemoveURLSchemeRegisteredAsBypassingContentSecurityPolicyBody>(*state, "removeURLSchemeRegisteredAsBypassingContentSecurityPolicy");
6100}
6101
6102static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterDefaultPortForProtocolBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6103{
6104 UNUSED_PARAM(state);
6105 UNUSED_PARAM(throwScope);
6106 auto& impl = castedThis->wrapped();
6107 if (UNLIKELY(state->argumentCount() < 2))
6108 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6109 auto port = convert<IDLUnsignedShort>(*state, state->uncheckedArgument(0));
6110 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6111 auto scheme = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
6112 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6113 impl.registerDefaultPortForProtocol(WTFMove(port), WTFMove(scheme));
6114 return JSValue::encode(jsUndefined());
6115}
6116
6117EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterDefaultPortForProtocol(ExecState* state)
6118{
6119 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterDefaultPortForProtocolBody>(*state, "registerDefaultPortForProtocol");
6120}
6121
6122static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMallocStatisticsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6123{
6124 UNUSED_PARAM(state);
6125 UNUSED_PARAM(throwScope);
6126 auto& impl = castedThis->wrapped();
6127 return JSValue::encode(toJS<IDLInterface<MallocStatistics>>(*state, *castedThis->globalObject(), impl.mallocStatistics()));
6128}
6129
6130EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMallocStatistics(ExecState* state)
6131{
6132 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMallocStatisticsBody>(*state, "mallocStatistics");
6133}
6134
6135static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTypeConversionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6136{
6137 UNUSED_PARAM(state);
6138 UNUSED_PARAM(throwScope);
6139 auto& impl = castedThis->wrapped();
6140 return JSValue::encode(toJS<IDLInterface<TypeConversions>>(*state, *castedThis->globalObject(), impl.typeConversions()));
6141}
6142
6143EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTypeConversions(ExecState* state)
6144{
6145 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTypeConversionsBody>(*state, "typeConversions");
6146}
6147
6148static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMemoryInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6149{
6150 UNUSED_PARAM(state);
6151 UNUSED_PARAM(throwScope);
6152 auto& impl = castedThis->wrapped();
6153 return JSValue::encode(toJS<IDLInterface<MemoryInfo>>(*state, *castedThis->globalObject(), impl.memoryInfo()));
6154}
6155
6156EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMemoryInfo(ExecState* state)
6157{
6158 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMemoryInfoBody>(*state, "memoryInfo");
6159}
6160
6161static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetReferencedFilePathsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6162{
6163 UNUSED_PARAM(state);
6164 UNUSED_PARAM(throwScope);
6165 auto& impl = castedThis->wrapped();
6166 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.getReferencedFilePaths()));
6167}
6168
6169EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetReferencedFilePaths(ExecState* state)
6170{
6171 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetReferencedFilePathsBody>(*state, "getReferencedFilePaths");
6172}
6173
6174static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingRepaintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6175{
6176 UNUSED_PARAM(state);
6177 UNUSED_PARAM(throwScope);
6178 auto& impl = castedThis->wrapped();
6179 propagateException(*state, throwScope, impl.startTrackingRepaints());
6180 return JSValue::encode(jsUndefined());
6181}
6182
6183EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingRepaints(ExecState* state)
6184{
6185 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingRepaintsBody>(*state, "startTrackingRepaints");
6186}
6187
6188static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStopTrackingRepaintsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6189{
6190 UNUSED_PARAM(state);
6191 UNUSED_PARAM(throwScope);
6192 auto& impl = castedThis->wrapped();
6193 propagateException(*state, throwScope, impl.stopTrackingRepaints());
6194 return JSValue::encode(jsUndefined());
6195}
6196
6197EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopTrackingRepaints(ExecState* state)
6198{
6199 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStopTrackingRepaintsBody>(*state, "stopTrackingRepaints");
6200}
6201
6202static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingLayerFlushesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6203{
6204 UNUSED_PARAM(state);
6205 UNUSED_PARAM(throwScope);
6206 auto& impl = castedThis->wrapped();
6207 propagateException(*state, throwScope, impl.startTrackingLayerFlushes());
6208 return JSValue::encode(jsUndefined());
6209}
6210
6211EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingLayerFlushes(ExecState* state)
6212{
6213 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingLayerFlushesBody>(*state, "startTrackingLayerFlushes");
6214}
6215
6216static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLayerFlushCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6217{
6218 UNUSED_PARAM(state);
6219 UNUSED_PARAM(throwScope);
6220 auto& impl = castedThis->wrapped();
6221 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.layerFlushCount()));
6222}
6223
6224EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLayerFlushCount(ExecState* state)
6225{
6226 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLayerFlushCountBody>(*state, "layerFlushCount");
6227}
6228
6229static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsTimerThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6230{
6231 UNUSED_PARAM(state);
6232 UNUSED_PARAM(throwScope);
6233 auto& impl = castedThis->wrapped();
6234 if (UNLIKELY(state->argumentCount() < 1))
6235 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6236 auto timerHandle = convert<IDLLong>(*state, state->uncheckedArgument(0));
6237 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6238 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isTimerThrottled(WTFMove(timerHandle))));
6239}
6240
6241EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsTimerThrottled(ExecState* state)
6242{
6243 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsTimerThrottledBody>(*state, "isTimerThrottled");
6244}
6245
6246static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6247{
6248 UNUSED_PARAM(state);
6249 UNUSED_PARAM(throwScope);
6250 auto& impl = castedThis->wrapped();
6251 return JSValue::encode(toJS<IDLBoolean>(impl.isRequestAnimationFrameThrottled()));
6252}
6253
6254EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottled(ExecState* state)
6255{
6256 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsRequestAnimationFrameThrottledBody>(*state, "isRequestAnimationFrameThrottled");
6257}
6258
6259static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAreTimersThrottledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6260{
6261 UNUSED_PARAM(state);
6262 UNUSED_PARAM(throwScope);
6263 auto& impl = castedThis->wrapped();
6264 return JSValue::encode(toJS<IDLBoolean>(impl.areTimersThrottled()));
6265}
6266
6267EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAreTimersThrottled(ExecState* state)
6268{
6269 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAreTimersThrottledBody>(*state, "areTimersThrottled");
6270}
6271
6272static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetLowPowerModeEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6273{
6274 UNUSED_PARAM(state);
6275 UNUSED_PARAM(throwScope);
6276 auto& impl = castedThis->wrapped();
6277 if (UNLIKELY(state->argumentCount() < 1))
6278 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6279 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6280 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6281 propagateException(*state, throwScope, impl.setLowPowerModeEnabled(WTFMove(enabled)));
6282 return JSValue::encode(jsUndefined());
6283}
6284
6285EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetLowPowerModeEnabled(ExecState* state)
6286{
6287 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetLowPowerModeEnabledBody>(*state, "setLowPowerModeEnabled");
6288}
6289
6290static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingStyleRecalcsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6291{
6292 UNUSED_PARAM(state);
6293 UNUSED_PARAM(throwScope);
6294 auto& impl = castedThis->wrapped();
6295 propagateException(*state, throwScope, impl.startTrackingStyleRecalcs());
6296 return JSValue::encode(jsUndefined());
6297}
6298
6299EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingStyleRecalcs(ExecState* state)
6300{
6301 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingStyleRecalcsBody>(*state, "startTrackingStyleRecalcs");
6302}
6303
6304static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStyleRecalcCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6305{
6306 UNUSED_PARAM(state);
6307 UNUSED_PARAM(throwScope);
6308 auto& impl = castedThis->wrapped();
6309 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.styleRecalcCount()));
6310}
6311
6312EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStyleRecalcCount(ExecState* state)
6313{
6314 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStyleRecalcCountBody>(*state, "styleRecalcCount");
6315}
6316
6317static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStartTrackingCompositingUpdatesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6318{
6319 UNUSED_PARAM(state);
6320 UNUSED_PARAM(throwScope);
6321 auto& impl = castedThis->wrapped();
6322 propagateException(*state, throwScope, impl.startTrackingCompositingUpdates());
6323 return JSValue::encode(jsUndefined());
6324}
6325
6326EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStartTrackingCompositingUpdates(ExecState* state)
6327{
6328 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStartTrackingCompositingUpdatesBody>(*state, "startTrackingCompositingUpdates");
6329}
6330
6331static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCompositingUpdateCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6332{
6333 UNUSED_PARAM(state);
6334 UNUSED_PARAM(throwScope);
6335 auto& impl = castedThis->wrapped();
6336 return JSValue::encode(toJS<IDLUnsignedLong>(*state, throwScope, impl.compositingUpdateCount()));
6337}
6338
6339EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCompositingUpdateCount(ExecState* state)
6340{
6341 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCompositingUpdateCountBody>(*state, "compositingUpdateCount");
6342}
6343
6344static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6345{
6346 UNUSED_PARAM(state);
6347 UNUSED_PARAM(throwScope);
6348 auto& impl = castedThis->wrapped();
6349 auto node = convert<IDLNullable<IDLInterface<Node>>>(*state, state->argument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "node", "Internals", "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks", "Node"); });
6350 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6351 propagateException(*state, throwScope, impl.updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(WTFMove(node)));
6352 return JSValue::encode(jsUndefined());
6353}
6354
6355EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(ExecState* state)
6356{
6357 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasksBody>(*state, "updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks");
6358}
6359
6360static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCurrentCursorInfoBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6361{
6362 UNUSED_PARAM(state);
6363 UNUSED_PARAM(throwScope);
6364 auto& impl = castedThis->wrapped();
6365 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.getCurrentCursorInfo()));
6366}
6367
6368EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentCursorInfo(ExecState* state)
6369{
6370 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCurrentCursorInfoBody>(*state, "getCurrentCursorInfo");
6371}
6372
6373static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkerTextForListItemBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6374{
6375 UNUSED_PARAM(state);
6376 UNUSED_PARAM(throwScope);
6377 auto& impl = castedThis->wrapped();
6378 if (UNLIKELY(state->argumentCount() < 1))
6379 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6380 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "markerTextForListItem", "Element"); });
6381 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6382 return JSValue::encode(toJS<IDLDOMString>(*state, impl.markerTextForListItem(*element)));
6383}
6384
6385EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkerTextForListItem(ExecState* state)
6386{
6387 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkerTextForListItemBody>(*state, "markerTextForListItem");
6388}
6389
6390static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionToolTipFromElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6391{
6392 UNUSED_PARAM(state);
6393 UNUSED_PARAM(throwScope);
6394 auto& impl = castedThis->wrapped();
6395 if (UNLIKELY(state->argumentCount() < 1))
6396 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6397 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "toolTipFromElement", "Element"); });
6398 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6399 return JSValue::encode(toJS<IDLDOMString>(*state, impl.toolTipFromElement(*element)));
6400}
6401
6402EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionToolTipFromElement(ExecState* state)
6403{
6404 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionToolTipFromElementBody>(*state, "toolTipFromElement");
6405}
6406
6407static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDeserializeBufferBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6408{
6409 UNUSED_PARAM(state);
6410 UNUSED_PARAM(throwScope);
6411 auto& impl = castedThis->wrapped();
6412 if (UNLIKELY(state->argumentCount() < 1))
6413 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6414 auto buffer = convert<IDLArrayBuffer>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "deserializeBuffer", "ArrayBuffer"); });
6415 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6416 return JSValue::encode(toJS<IDLSerializedScriptValue<SerializedScriptValue>>(*state, *castedThis->globalObject(), impl.deserializeBuffer(*buffer)));
6417}
6418
6419EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDeserializeBuffer(ExecState* state)
6420{
6421 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDeserializeBufferBody>(*state, "deserializeBuffer");
6422}
6423
6424static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSerializeObjectBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6425{
6426 UNUSED_PARAM(state);
6427 UNUSED_PARAM(throwScope);
6428 auto& impl = castedThis->wrapped();
6429 if (UNLIKELY(state->argumentCount() < 1))
6430 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6431 auto object = convert<IDLSerializedScriptValue<SerializedScriptValue>>(*state, state->uncheckedArgument(0));
6432 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6433 return JSValue::encode(toJS<IDLArrayBuffer>(*state, *castedThis->globalObject(), impl.serializeObject(WTFMove(object))));
6434}
6435
6436EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSerializeObject(ExecState* state)
6437{
6438 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSerializeObjectBody>(*state, "serializeObject");
6439}
6440
6441static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsFromCurrentWorldBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6442{
6443 UNUSED_PARAM(state);
6444 UNUSED_PARAM(throwScope);
6445 auto& impl = castedThis->wrapped();
6446 if (UNLIKELY(state->argumentCount() < 1))
6447 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6448 auto obj = convert<IDLAny>(*state, state->uncheckedArgument(0));
6449 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6450 return JSValue::encode(toJS<IDLBoolean>(impl.isFromCurrentWorld(WTFMove(obj))));
6451}
6452
6453EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsFromCurrentWorld(ExecState* state)
6454{
6455 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsFromCurrentWorldBody>(*state, "isFromCurrentWorld");
6456}
6457
6458static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUsesOverlayScrollbarsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6459{
6460 UNUSED_PARAM(state);
6461 UNUSED_PARAM(throwScope);
6462 auto& impl = castedThis->wrapped();
6463 if (UNLIKELY(state->argumentCount() < 1))
6464 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6465 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6466 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6467 impl.setUsesOverlayScrollbars(WTFMove(enabled));
6468 return JSValue::encode(jsUndefined());
6469}
6470
6471EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesOverlayScrollbars(ExecState* state)
6472{
6473 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUsesOverlayScrollbarsBody>(*state, "setUsesOverlayScrollbars");
6474}
6475
6476static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUsesMockScrollAnimatorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6477{
6478 UNUSED_PARAM(state);
6479 UNUSED_PARAM(throwScope);
6480 auto& impl = castedThis->wrapped();
6481 if (UNLIKELY(state->argumentCount() < 1))
6482 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6483 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6484 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6485 impl.setUsesMockScrollAnimator(WTFMove(enabled));
6486 return JSValue::encode(jsUndefined());
6487}
6488
6489EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUsesMockScrollAnimator(ExecState* state)
6490{
6491 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUsesMockScrollAnimatorBody>(*state, "setUsesMockScrollAnimator");
6492}
6493
6494static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionForceReloadBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6495{
6496 UNUSED_PARAM(state);
6497 UNUSED_PARAM(throwScope);
6498 auto& impl = castedThis->wrapped();
6499 if (UNLIKELY(state->argumentCount() < 1))
6500 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6501 auto endToEnd = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6502 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6503 impl.forceReload(WTFMove(endToEnd));
6504 return JSValue::encode(jsUndefined());
6505}
6506
6507EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionForceReload(ExecState* state)
6508{
6509 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionForceReloadBody>(*state, "forceReload");
6510}
6511
6512static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReloadExpiredOnlyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6513{
6514 UNUSED_PARAM(state);
6515 UNUSED_PARAM(throwScope);
6516 auto& impl = castedThis->wrapped();
6517 impl.reloadExpiredOnly();
6518 return JSValue::encode(jsUndefined());
6519}
6520
6521EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadExpiredOnly(ExecState* state)
6522{
6523 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReloadExpiredOnlyBody>(*state, "reloadExpiredOnly");
6524}
6525
6526static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableAutoSizeModeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6527{
6528 UNUSED_PARAM(state);
6529 UNUSED_PARAM(throwScope);
6530 auto& impl = castedThis->wrapped();
6531 if (UNLIKELY(state->argumentCount() < 3))
6532 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6533 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
6534 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6535 auto width = convert<IDLLong>(*state, state->uncheckedArgument(1));
6536 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6537 auto height = convert<IDLLong>(*state, state->uncheckedArgument(2));
6538 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6539 impl.enableAutoSizeMode(WTFMove(enabled), WTFMove(width), WTFMove(height));
6540 return JSValue::encode(jsUndefined());
6541}
6542
6543EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableAutoSizeMode(ExecState* state)
6544{
6545 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableAutoSizeModeBody>(*state, "enableAutoSizeMode");
6546}
6547
6548#if ENABLE(VIDEO)
6549static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaResponseSourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6550{
6551 UNUSED_PARAM(state);
6552 UNUSED_PARAM(throwScope);
6553 auto& impl = castedThis->wrapped();
6554 if (UNLIKELY(state->argumentCount() < 1))
6555 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6556 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "mediaResponseSources", "HTMLMediaElement"); });
6557 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6558 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.mediaResponseSources(*media)));
6559}
6560
6561EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseSources(ExecState* state)
6562{
6563 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaResponseSourcesBody>(*state, "mediaResponseSources");
6564}
6565
6566#endif
6567
6568#if ENABLE(VIDEO)
6569static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaResponseContentRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6570{
6571 UNUSED_PARAM(state);
6572 UNUSED_PARAM(throwScope);
6573 auto& impl = castedThis->wrapped();
6574 if (UNLIKELY(state->argumentCount() < 1))
6575 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6576 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "mediaResponseContentRanges", "HTMLMediaElement"); });
6577 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6578 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.mediaResponseContentRanges(*media)));
6579}
6580
6581EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaResponseContentRanges(ExecState* state)
6582{
6583 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaResponseContentRangesBody>(*state, "mediaResponseContentRanges");
6584}
6585
6586#endif
6587
6588#if ENABLE(VIDEO)
6589static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateAudioInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6590{
6591 UNUSED_PARAM(state);
6592 UNUSED_PARAM(throwScope);
6593 auto& impl = castedThis->wrapped();
6594 if (UNLIKELY(state->argumentCount() < 1))
6595 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6596 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "simulateAudioInterruption", "HTMLMediaElement"); });
6597 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6598 impl.simulateAudioInterruption(*element);
6599 return JSValue::encode(jsUndefined());
6600}
6601
6602EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateAudioInterruption(ExecState* state)
6603{
6604 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateAudioInterruptionBody>(*state, "simulateAudioInterruption");
6605}
6606
6607#endif
6608
6609#if ENABLE(VIDEO)
6610static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaElementHasCharacteristicBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6611{
6612 UNUSED_PARAM(state);
6613 UNUSED_PARAM(throwScope);
6614 auto& impl = castedThis->wrapped();
6615 if (UNLIKELY(state->argumentCount() < 2))
6616 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6617 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaElementHasCharacteristic", "HTMLMediaElement"); });
6618 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6619 auto characteristic = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
6620 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6621 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.mediaElementHasCharacteristic(*element, WTFMove(characteristic))));
6622}
6623
6624EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementHasCharacteristic(ExecState* state)
6625{
6626 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaElementHasCharacteristicBody>(*state, "mediaElementHasCharacteristic");
6627}
6628
6629#endif
6630
6631#if ENABLE(VIDEO)
6632static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginSimulatedHDCPErrorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6633{
6634 UNUSED_PARAM(state);
6635 UNUSED_PARAM(throwScope);
6636 auto& impl = castedThis->wrapped();
6637 if (UNLIKELY(state->argumentCount() < 1))
6638 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6639 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "beginSimulatedHDCPError", "HTMLMediaElement"); });
6640 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6641 impl.beginSimulatedHDCPError(*media);
6642 return JSValue::encode(jsUndefined());
6643}
6644
6645EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginSimulatedHDCPError(ExecState* state)
6646{
6647 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginSimulatedHDCPErrorBody>(*state, "beginSimulatedHDCPError");
6648}
6649
6650#endif
6651
6652#if ENABLE(VIDEO)
6653static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndSimulatedHDCPErrorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6654{
6655 UNUSED_PARAM(state);
6656 UNUSED_PARAM(throwScope);
6657 auto& impl = castedThis->wrapped();
6658 if (UNLIKELY(state->argumentCount() < 1))
6659 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6660 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "endSimulatedHDCPError", "HTMLMediaElement"); });
6661 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6662 impl.endSimulatedHDCPError(*media);
6663 return JSValue::encode(jsUndefined());
6664}
6665
6666EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndSimulatedHDCPError(ExecState* state)
6667{
6668 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndSimulatedHDCPErrorBody>(*state, "endSimulatedHDCPError");
6669}
6670
6671#endif
6672
6673#if ENABLE(VIDEO)
6674static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementShouldBufferDataBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6675{
6676 UNUSED_PARAM(state);
6677 UNUSED_PARAM(throwScope);
6678 auto& impl = castedThis->wrapped();
6679 if (UNLIKELY(state->argumentCount() < 1))
6680 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6681 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "elementShouldBufferData", "HTMLMediaElement"); });
6682 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6683 return JSValue::encode(toJS<IDLBoolean>(impl.elementShouldBufferData(*media)));
6684}
6685
6686EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementShouldBufferData(ExecState* state)
6687{
6688 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementShouldBufferDataBody>(*state, "elementShouldBufferData");
6689}
6690
6691#endif
6692
6693#if ENABLE(VIDEO)
6694static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementBufferingPolicyBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6695{
6696 UNUSED_PARAM(state);
6697 UNUSED_PARAM(throwScope);
6698 auto& impl = castedThis->wrapped();
6699 if (UNLIKELY(state->argumentCount() < 1))
6700 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6701 auto media = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "media", "Internals", "elementBufferingPolicy", "HTMLMediaElement"); });
6702 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6703 return JSValue::encode(toJS<IDLDOMString>(*state, impl.elementBufferingPolicy(*media)));
6704}
6705
6706EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementBufferingPolicy(ExecState* state)
6707{
6708 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementBufferingPolicyBody>(*state, "elementBufferingPolicy");
6709}
6710
6711#endif
6712
6713#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
6714static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInitializeMockCDMBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6715{
6716 UNUSED_PARAM(state);
6717 UNUSED_PARAM(throwScope);
6718 auto& impl = castedThis->wrapped();
6719 impl.initializeMockCDM();
6720 return JSValue::encode(jsUndefined());
6721}
6722
6723EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockCDM(ExecState* state)
6724{
6725 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInitializeMockCDMBody>(*state, "initializeMockCDM");
6726}
6727
6728#endif
6729
6730#if ENABLE(ENCRYPTED_MEDIA)
6731static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRegisterMockCDMBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6732{
6733 UNUSED_PARAM(state);
6734 UNUSED_PARAM(throwScope);
6735 auto& impl = castedThis->wrapped();
6736 return JSValue::encode(toJS<IDLInterface<MockCDMFactory>>(*state, *castedThis->globalObject(), impl.registerMockCDM()));
6737}
6738
6739EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRegisterMockCDM(ExecState* state)
6740{
6741 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRegisterMockCDMBody>(*state, "registerMockCDM");
6742}
6743
6744#endif
6745
6746static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableMockMediaCapabilitiesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6747{
6748 UNUSED_PARAM(state);
6749 UNUSED_PARAM(throwScope);
6750 auto& impl = castedThis->wrapped();
6751 impl.enableMockMediaCapabilities();
6752 return JSValue::encode(jsUndefined());
6753}
6754
6755EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockMediaCapabilities(ExecState* state)
6756{
6757 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableMockMediaCapabilitiesBody>(*state, "enableMockMediaCapabilities");
6758}
6759
6760#if ENABLE(SPEECH_SYNTHESIS)
6761static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnableMockSpeechSynthesizerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6762{
6763 UNUSED_PARAM(state);
6764 UNUSED_PARAM(throwScope);
6765 auto& impl = castedThis->wrapped();
6766 impl.enableMockSpeechSynthesizer();
6767 return JSValue::encode(jsUndefined());
6768}
6769
6770EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnableMockSpeechSynthesizer(ExecState* state)
6771{
6772 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnableMockSpeechSynthesizerBody>(*state, "enableMockSpeechSynthesizer");
6773}
6774
6775#endif
6776
6777static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetImageSourceURLBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6778{
6779 UNUSED_PARAM(state);
6780 UNUSED_PARAM(throwScope);
6781 auto& impl = castedThis->wrapped();
6782 if (UNLIKELY(state->argumentCount() < 1))
6783 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6784 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "getImageSourceURL", "Element"); });
6785 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6786 return JSValue::encode(toJS<IDLDOMString>(*state, impl.getImageSourceURL(*element)));
6787}
6788
6789EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetImageSourceURL(ExecState* state)
6790{
6791 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetImageSourceURLBody>(*state, "getImageSourceURL");
6792}
6793
6794#if ENABLE(VIDEO_TRACK)
6795static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCaptionsStyleSheetOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6796{
6797 UNUSED_PARAM(state);
6798 UNUSED_PARAM(throwScope);
6799 auto& impl = castedThis->wrapped();
6800 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.captionsStyleSheetOverride()));
6801}
6802
6803EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCaptionsStyleSheetOverride(ExecState* state)
6804{
6805 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCaptionsStyleSheetOverrideBody>(*state, "captionsStyleSheetOverride");
6806}
6807
6808#endif
6809
6810#if ENABLE(VIDEO_TRACK)
6811static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6812{
6813 UNUSED_PARAM(state);
6814 UNUSED_PARAM(throwScope);
6815 auto& impl = castedThis->wrapped();
6816 if (UNLIKELY(state->argumentCount() < 1))
6817 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6818 auto override = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6819 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6820 propagateException(*state, throwScope, impl.setCaptionsStyleSheetOverride(WTFMove(override)));
6821 return JSValue::encode(jsUndefined());
6822}
6823
6824EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverride(ExecState* state)
6825{
6826 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptionsStyleSheetOverrideBody>(*state, "setCaptionsStyleSheetOverride");
6827}
6828
6829#endif
6830
6831#if ENABLE(VIDEO_TRACK)
6832static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6833{
6834 UNUSED_PARAM(state);
6835 UNUSED_PARAM(throwScope);
6836 auto& impl = castedThis->wrapped();
6837 if (UNLIKELY(state->argumentCount() < 1))
6838 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6839 auto language = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6840 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6841 propagateException(*state, throwScope, impl.setPrimaryAudioTrackLanguageOverride(WTFMove(language)));
6842 return JSValue::encode(jsUndefined());
6843}
6844
6845EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverride(ExecState* state)
6846{
6847 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPrimaryAudioTrackLanguageOverrideBody>(*state, "setPrimaryAudioTrackLanguageOverride");
6848}
6849
6850#endif
6851
6852#if ENABLE(VIDEO_TRACK)
6853static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptionDisplayModeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6854{
6855 UNUSED_PARAM(state);
6856 UNUSED_PARAM(throwScope);
6857 auto& impl = castedThis->wrapped();
6858 if (UNLIKELY(state->argumentCount() < 1))
6859 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6860 auto mode = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
6861 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6862 propagateException(*state, throwScope, impl.setCaptionDisplayMode(WTFMove(mode)));
6863 return JSValue::encode(jsUndefined());
6864}
6865
6866EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptionDisplayMode(ExecState* state)
6867{
6868 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptionDisplayModeBody>(*state, "setCaptionDisplayMode");
6869}
6870
6871#endif
6872
6873#if ENABLE(VIDEO_TRACK)
6874static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateGenericCueBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6875{
6876 UNUSED_PARAM(state);
6877 UNUSED_PARAM(throwScope);
6878 auto& impl = castedThis->wrapped();
6879 if (UNLIKELY(state->argumentCount() < 3))
6880 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6881 auto startTime = convert<IDLDouble>(*state, state->uncheckedArgument(0));
6882 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6883 auto endTime = convert<IDLDouble>(*state, state->uncheckedArgument(1));
6884 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6885 auto text = convert<IDLDOMString>(*state, state->uncheckedArgument(2));
6886 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6887 return JSValue::encode(toJS<IDLInterface<TextTrackCueGeneric>>(*state, *castedThis->globalObject(), impl.createGenericCue(WTFMove(startTime), WTFMove(endTime), WTFMove(text))));
6888}
6889
6890EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateGenericCue(ExecState* state)
6891{
6892 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateGenericCueBody>(*state, "createGenericCue");
6893}
6894
6895#endif
6896
6897#if ENABLE(VIDEO)
6898static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateTimeRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6899{
6900 UNUSED_PARAM(state);
6901 UNUSED_PARAM(throwScope);
6902 auto& impl = castedThis->wrapped();
6903 if (UNLIKELY(state->argumentCount() < 2))
6904 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6905 auto startTimes = convert<IDLFloat32Array>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "startTimes", "Internals", "createTimeRanges", "Float32Array"); });
6906 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6907 auto endTimes = convert<IDLFloat32Array>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "endTimes", "Internals", "createTimeRanges", "Float32Array"); });
6908 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6909 return JSValue::encode(toJS<IDLInterface<TimeRanges>>(*state, *castedThis->globalObject(), impl.createTimeRanges(startTimes.releaseNonNull(), endTimes.releaseNonNull())));
6910}
6911
6912EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateTimeRanges(ExecState* state)
6913{
6914 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateTimeRangesBody>(*state, "createTimeRanges");
6915}
6916
6917#endif
6918
6919#if ENABLE(VIDEO)
6920static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClosestTimeToTimeRangesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6921{
6922 UNUSED_PARAM(state);
6923 UNUSED_PARAM(throwScope);
6924 auto& impl = castedThis->wrapped();
6925 if (UNLIKELY(state->argumentCount() < 2))
6926 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6927 auto time = convert<IDLUnrestrictedDouble>(*state, state->uncheckedArgument(0));
6928 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6929 auto ranges = convert<IDLInterface<TimeRanges>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "ranges", "Internals", "closestTimeToTimeRanges", "TimeRanges"); });
6930 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6931 return JSValue::encode(toJS<IDLUnrestrictedDouble>(impl.closestTimeToTimeRanges(WTFMove(time), *ranges)));
6932}
6933
6934EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClosestTimeToTimeRanges(ExecState* state)
6935{
6936 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClosestTimeToTimeRangesBody>(*state, "closestTimeToTimeRanges");
6937}
6938
6939#endif
6940
6941static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSelectPopupVisibleBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6942{
6943 UNUSED_PARAM(state);
6944 UNUSED_PARAM(throwScope);
6945 auto& impl = castedThis->wrapped();
6946 if (UNLIKELY(state->argumentCount() < 1))
6947 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6948 auto element = convert<IDLInterface<HTMLSelectElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSelectPopupVisible", "HTMLSelectElement"); });
6949 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6950 return JSValue::encode(toJS<IDLBoolean>(impl.isSelectPopupVisible(*element)));
6951}
6952
6953EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSelectPopupVisible(ExecState* state)
6954{
6955 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSelectPopupVisibleBody>(*state, "isSelectPopupVisible");
6956}
6957
6958static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscuredBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6959{
6960 UNUSED_PARAM(state);
6961 UNUSED_PARAM(throwScope);
6962 auto& impl = castedThis->wrapped();
6963 if (UNLIKELY(state->argumentCount() < 1))
6964 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6965 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPluginUnavailabilityIndicatorObscured", "Element"); });
6966 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6967 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.isPluginUnavailabilityIndicatorObscured(*element)));
6968}
6969
6970EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscured(ExecState* state)
6971{
6972 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPluginUnavailabilityIndicatorObscuredBody>(*state, "isPluginUnavailabilityIndicatorObscured");
6973}
6974
6975static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUnavailablePluginReplacementTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6976{
6977 UNUSED_PARAM(state);
6978 UNUSED_PARAM(throwScope);
6979 auto& impl = castedThis->wrapped();
6980 if (UNLIKELY(state->argumentCount() < 1))
6981 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6982 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "unavailablePluginReplacementText", "Element"); });
6983 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
6984 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.unavailablePluginReplacementText(*element)));
6985}
6986
6987EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUnavailablePluginReplacementText(ExecState* state)
6988{
6989 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUnavailablePluginReplacementTextBody>(*state, "unavailablePluginReplacementText");
6990}
6991
6992static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsPluginSnapshottedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
6993{
6994 UNUSED_PARAM(state);
6995 UNUSED_PARAM(throwScope);
6996 auto& impl = castedThis->wrapped();
6997 if (UNLIKELY(state->argumentCount() < 1))
6998 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
6999 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isPluginSnapshotted", "Element"); });
7000 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7001 return JSValue::encode(toJS<IDLBoolean>(impl.isPluginSnapshotted(*element)));
7002}
7003
7004EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsPluginSnapshotted(ExecState* state)
7005{
7006 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsPluginSnapshottedBody>(*state, "isPluginSnapshotted");
7007}
7008
7009static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPluginIsBelowSizeThresholdBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7010{
7011 UNUSED_PARAM(state);
7012 UNUSED_PARAM(throwScope);
7013 auto& impl = castedThis->wrapped();
7014 if (UNLIKELY(state->argumentCount() < 1))
7015 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7016 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "pluginIsBelowSizeThreshold", "Element"); });
7017 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7018 return JSValue::encode(toJS<IDLBoolean>(impl.pluginIsBelowSizeThreshold(*element)));
7019}
7020
7021EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginIsBelowSizeThreshold(ExecState* state)
7022{
7023 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPluginIsBelowSizeThresholdBody>(*state, "pluginIsBelowSizeThreshold");
7024}
7025
7026static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSelectionBoundsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7027{
7028 UNUSED_PARAM(state);
7029 UNUSED_PARAM(throwScope);
7030 auto& impl = castedThis->wrapped();
7031 return JSValue::encode(toJS<IDLInterface<DOMRect>>(*state, *castedThis->globalObject(), throwScope, impl.selectionBounds()));
7032}
7033
7034EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSelectionBounds(ExecState* state)
7035{
7036 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSelectionBoundsBody>(*state, "selectionBounds");
7037}
7038
7039static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetSelectionWithoutValidationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7040{
7041 UNUSED_PARAM(state);
7042 UNUSED_PARAM(throwScope);
7043 auto& impl = castedThis->wrapped();
7044 if (UNLIKELY(state->argumentCount() < 4))
7045 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7046 auto baseNode = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "baseNode", "Internals", "setSelectionWithoutValidation", "Node"); });
7047 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7048 auto baseOffset = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(1));
7049 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7050 auto extentNode = convert<IDLNullable<IDLInterface<Node>>>(*state, state->uncheckedArgument(2), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 2, "extentNode", "Internals", "setSelectionWithoutValidation", "Node"); });
7051 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7052 auto extentOffset = convert<IDLUnsignedLong>(*state, state->uncheckedArgument(3));
7053 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7054 impl.setSelectionWithoutValidation(*baseNode, WTFMove(baseOffset), WTFMove(extentNode), WTFMove(extentOffset));
7055 return JSValue::encode(jsUndefined());
7056}
7057
7058EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSelectionWithoutValidation(ExecState* state)
7059{
7060 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetSelectionWithoutValidationBody>(*state, "setSelectionWithoutValidation");
7061}
7062
7063#if ENABLE(MEDIA_SOURCE)
7064static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInitializeMockMediaSourceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7065{
7066 UNUSED_PARAM(state);
7067 UNUSED_PARAM(throwScope);
7068 auto& impl = castedThis->wrapped();
7069 impl.initializeMockMediaSource();
7070 return JSValue::encode(jsUndefined());
7071}
7072
7073EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInitializeMockMediaSource(ExecState* state)
7074{
7075 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInitializeMockMediaSourceBody>(*state, "initializeMockMediaSource");
7076}
7077
7078#endif
7079
7080#if ENABLE(MEDIA_SOURCE)
7081static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBufferedSamplesForTrackIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7082{
7083 UNUSED_PARAM(state);
7084 UNUSED_PARAM(throwScope);
7085 auto& impl = castedThis->wrapped();
7086 if (UNLIKELY(state->argumentCount() < 2))
7087 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7088 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "bufferedSamplesForTrackID", "SourceBuffer"); });
7089 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7090 auto trackID = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7091 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7092 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.bufferedSamplesForTrackID(*buffer, WTFMove(trackID))));
7093}
7094
7095EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBufferedSamplesForTrackID(ExecState* state)
7096{
7097 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBufferedSamplesForTrackIDBody>(*state, "bufferedSamplesForTrackID");
7098}
7099
7100#endif
7101
7102#if ENABLE(MEDIA_SOURCE)
7103static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEnqueuedSamplesForTrackIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7104{
7105 UNUSED_PARAM(state);
7106 UNUSED_PARAM(throwScope);
7107 auto& impl = castedThis->wrapped();
7108 if (UNLIKELY(state->argumentCount() < 2))
7109 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7110 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "enqueuedSamplesForTrackID", "SourceBuffer"); });
7111 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7112 auto trackID = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7113 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7114 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.enqueuedSamplesForTrackID(*buffer, WTFMove(trackID))));
7115}
7116
7117EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEnqueuedSamplesForTrackID(ExecState* state)
7118{
7119 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEnqueuedSamplesForTrackIDBody>(*state, "enqueuedSamplesForTrackID");
7120}
7121
7122#endif
7123
7124#if ENABLE(MEDIA_SOURCE)
7125static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShouldGenerateTimestampsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7126{
7127 UNUSED_PARAM(state);
7128 UNUSED_PARAM(throwScope);
7129 auto& impl = castedThis->wrapped();
7130 if (UNLIKELY(state->argumentCount() < 2))
7131 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7132 auto buffer = convert<IDLInterface<SourceBuffer>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "buffer", "Internals", "setShouldGenerateTimestamps", "SourceBuffer"); });
7133 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7134 auto flag = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
7135 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7136 impl.setShouldGenerateTimestamps(*buffer, WTFMove(flag));
7137 return JSValue::encode(jsUndefined());
7138}
7139
7140EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShouldGenerateTimestamps(ExecState* state)
7141{
7142 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShouldGenerateTimestampsBody>(*state, "setShouldGenerateTimestamps");
7143}
7144
7145#endif
7146
7147#if ENABLE(VIDEO)
7148static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBeginMediaSessionInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7149{
7150 UNUSED_PARAM(state);
7151 UNUSED_PARAM(throwScope);
7152 auto& impl = castedThis->wrapped();
7153 if (UNLIKELY(state->argumentCount() < 1))
7154 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7155 auto interruptionType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7156 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7157 propagateException(*state, throwScope, impl.beginMediaSessionInterruption(WTFMove(interruptionType)));
7158 return JSValue::encode(jsUndefined());
7159}
7160
7161EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBeginMediaSessionInterruption(ExecState* state)
7162{
7163 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBeginMediaSessionInterruptionBody>(*state, "beginMediaSessionInterruption");
7164}
7165
7166#endif
7167
7168#if ENABLE(VIDEO)
7169static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEndMediaSessionInterruptionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7170{
7171 UNUSED_PARAM(state);
7172 UNUSED_PARAM(throwScope);
7173 auto& impl = castedThis->wrapped();
7174 if (UNLIKELY(state->argumentCount() < 1))
7175 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7176 auto flags = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7177 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7178 impl.endMediaSessionInterruption(WTFMove(flags));
7179 return JSValue::encode(jsUndefined());
7180}
7181
7182EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEndMediaSessionInterruption(ExecState* state)
7183{
7184 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEndMediaSessionInterruptionBody>(*state, "endMediaSessionInterruption");
7185}
7186
7187#endif
7188
7189#if ENABLE(MEDIA_SESSION)
7190static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotificationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7191{
7192 UNUSED_PARAM(state);
7193 UNUSED_PARAM(throwScope);
7194 auto& impl = castedThis->wrapped();
7195 if (UNLIKELY(state->argumentCount() < 1))
7196 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7197 auto category = convert<IDLEnumeration<Internals::MediaSessionInterruptingCategory>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "category", "Internals", "sendMediaSessionStartOfInterruptionNotification", expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()); });
7198 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7199 impl.sendMediaSessionStartOfInterruptionNotification(WTFMove(category));
7200 return JSValue::encode(jsUndefined());
7201}
7202
7203EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotification(ExecState* state)
7204{
7205 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaSessionStartOfInterruptionNotificationBody>(*state, "sendMediaSessionStartOfInterruptionNotification");
7206}
7207
7208#endif
7209
7210#if ENABLE(MEDIA_SESSION)
7211static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotificationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7212{
7213 UNUSED_PARAM(state);
7214 UNUSED_PARAM(throwScope);
7215 auto& impl = castedThis->wrapped();
7216 if (UNLIKELY(state->argumentCount() < 1))
7217 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7218 auto category = convert<IDLEnumeration<Internals::MediaSessionInterruptingCategory>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "category", "Internals", "sendMediaSessionEndOfInterruptionNotification", expectedEnumerationValues<Internals::MediaSessionInterruptingCategory>()); });
7219 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7220 impl.sendMediaSessionEndOfInterruptionNotification(WTFMove(category));
7221 return JSValue::encode(jsUndefined());
7222}
7223
7224EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotification(ExecState* state)
7225{
7226 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaSessionEndOfInterruptionNotificationBody>(*state, "sendMediaSessionEndOfInterruptionNotification");
7227}
7228
7229#endif
7230
7231#if ENABLE(MEDIA_SESSION)
7232static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionCurrentStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7233{
7234 UNUSED_PARAM(state);
7235 UNUSED_PARAM(throwScope);
7236 auto& impl = castedThis->wrapped();
7237 if (UNLIKELY(state->argumentCount() < 1))
7238 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7239 auto session = convert<IDLInterface<MediaSession>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "session", "Internals", "mediaSessionCurrentState", "MediaSession"); });
7240 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7241 return JSValue::encode(toJS<IDLDOMString>(*state, impl.mediaSessionCurrentState(*session)));
7242}
7243
7244EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionCurrentState(ExecState* state)
7245{
7246 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionCurrentStateBody>(*state, "mediaSessionCurrentState");
7247}
7248
7249#endif
7250
7251#if ENABLE(MEDIA_SESSION)
7252static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaElementPlayerVolumeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7253{
7254 UNUSED_PARAM(state);
7255 UNUSED_PARAM(throwScope);
7256 auto& impl = castedThis->wrapped();
7257 if (UNLIKELY(state->argumentCount() < 1))
7258 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7259 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaElementPlayerVolume", "HTMLMediaElement"); });
7260 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7261 return JSValue::encode(toJS<IDLDouble>(impl.mediaElementPlayerVolume(*element)));
7262}
7263
7264EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaElementPlayerVolume(ExecState* state)
7265{
7266 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaElementPlayerVolumeBody>(*state, "mediaElementPlayerVolume");
7267}
7268
7269#endif
7270
7271#if ENABLE(MEDIA_SESSION)
7272static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSendMediaControlEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7273{
7274 UNUSED_PARAM(state);
7275 UNUSED_PARAM(throwScope);
7276 auto& impl = castedThis->wrapped();
7277 if (UNLIKELY(state->argumentCount() < 1))
7278 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7279 auto event = convert<IDLEnumeration<Internals::MediaControlEvent>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "event", "Internals", "sendMediaControlEvent", expectedEnumerationValues<Internals::MediaControlEvent>()); });
7280 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7281 impl.sendMediaControlEvent(WTFMove(event));
7282 return JSValue::encode(jsUndefined());
7283}
7284
7285EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSendMediaControlEvent(ExecState* state)
7286{
7287 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSendMediaControlEventBody>(*state, "sendMediaControlEvent");
7288}
7289
7290#endif
7291
7292#if ENABLE(VIDEO)
7293static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationWillBecomeInactiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7294{
7295 UNUSED_PARAM(state);
7296 UNUSED_PARAM(throwScope);
7297 auto& impl = castedThis->wrapped();
7298 impl.applicationWillBecomeInactive();
7299 return JSValue::encode(jsUndefined());
7300}
7301
7302EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillBecomeInactive(ExecState* state)
7303{
7304 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationWillBecomeInactiveBody>(*state, "applicationWillBecomeInactive");
7305}
7306
7307#endif
7308
7309#if ENABLE(VIDEO)
7310static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationDidBecomeActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7311{
7312 UNUSED_PARAM(state);
7313 UNUSED_PARAM(throwScope);
7314 auto& impl = castedThis->wrapped();
7315 impl.applicationDidBecomeActive();
7316 return JSValue::encode(jsUndefined());
7317}
7318
7319EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidBecomeActive(ExecState* state)
7320{
7321 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationDidBecomeActiveBody>(*state, "applicationDidBecomeActive");
7322}
7323
7324#endif
7325
7326#if ENABLE(VIDEO)
7327static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationWillEnterForegroundBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7328{
7329 UNUSED_PARAM(state);
7330 UNUSED_PARAM(throwScope);
7331 auto& impl = castedThis->wrapped();
7332 auto suspendedUnderLock = convert<IDLBoolean>(*state, state->argument(0));
7333 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7334 impl.applicationWillEnterForeground(WTFMove(suspendedUnderLock));
7335 return JSValue::encode(jsUndefined());
7336}
7337
7338EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationWillEnterForeground(ExecState* state)
7339{
7340 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationWillEnterForegroundBody>(*state, "applicationWillEnterForeground");
7341}
7342
7343#endif
7344
7345#if ENABLE(VIDEO)
7346static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplicationDidEnterBackgroundBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7347{
7348 UNUSED_PARAM(state);
7349 UNUSED_PARAM(throwScope);
7350 auto& impl = castedThis->wrapped();
7351 auto suspendedUnderLock = convert<IDLBoolean>(*state, state->argument(0));
7352 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7353 impl.applicationDidEnterBackground(WTFMove(suspendedUnderLock));
7354 return JSValue::encode(jsUndefined());
7355}
7356
7357EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplicationDidEnterBackground(ExecState* state)
7358{
7359 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplicationDidEnterBackgroundBody>(*state, "applicationDidEnterBackground");
7360}
7361
7362#endif
7363
7364#if ENABLE(VIDEO)
7365static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaSessionRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7366{
7367 UNUSED_PARAM(state);
7368 UNUSED_PARAM(throwScope);
7369 auto& impl = castedThis->wrapped();
7370 if (UNLIKELY(state->argumentCount() < 2))
7371 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7372 auto mediaType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7373 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7374 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7375 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7376 propagateException(*state, throwScope, impl.setMediaSessionRestrictions(WTFMove(mediaType), WTFMove(restrictions)));
7377 return JSValue::encode(jsUndefined());
7378}
7379
7380EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaSessionRestrictions(ExecState* state)
7381{
7382 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaSessionRestrictionsBody>(*state, "setMediaSessionRestrictions");
7383}
7384
7385#endif
7386
7387#if ENABLE(VIDEO)
7388static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7389{
7390 UNUSED_PARAM(state);
7391 UNUSED_PARAM(throwScope);
7392 auto& impl = castedThis->wrapped();
7393 if (UNLIKELY(state->argumentCount() < 1))
7394 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7395 auto mediaType = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7396 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7397 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.mediaSessionRestrictions(WTFMove(mediaType))));
7398}
7399
7400EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionRestrictions(ExecState* state)
7401{
7402 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionRestrictionsBody>(*state, "mediaSessionRestrictions");
7403}
7404
7405#endif
7406
7407#if ENABLE(VIDEO)
7408static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaElementRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7409{
7410 UNUSED_PARAM(state);
7411 UNUSED_PARAM(throwScope);
7412 auto& impl = castedThis->wrapped();
7413 if (UNLIKELY(state->argumentCount() < 2))
7414 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7415 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "setMediaElementRestrictions", "HTMLMediaElement"); });
7416 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7417 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7418 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7419 impl.setMediaElementRestrictions(*element, WTFMove(restrictions));
7420 return JSValue::encode(jsUndefined());
7421}
7422
7423EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaElementRestrictions(ExecState* state)
7424{
7425 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaElementRestrictionsBody>(*state, "setMediaElementRestrictions");
7426}
7427
7428#endif
7429
7430#if ENABLE(WEB_AUDIO)
7431static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAudioContextRestrictionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7432{
7433 UNUSED_PARAM(state);
7434 UNUSED_PARAM(throwScope);
7435 auto& impl = castedThis->wrapped();
7436 if (UNLIKELY(state->argumentCount() < 2))
7437 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7438 auto context = convert<IDLInterface<AudioContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "setAudioContextRestrictions", "AudioContext"); });
7439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7440 auto restrictions = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7441 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7442 impl.setAudioContextRestrictions(*context, WTFMove(restrictions));
7443 return JSValue::encode(jsUndefined());
7444}
7445
7446EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAudioContextRestrictions(ExecState* state)
7447{
7448 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAudioContextRestrictionsBody>(*state, "setAudioContextRestrictions");
7449}
7450
7451#endif
7452
7453#if ENABLE(VIDEO)
7454static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPostRemoteControlCommandBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7455{
7456 UNUSED_PARAM(state);
7457 UNUSED_PARAM(throwScope);
7458 auto& impl = castedThis->wrapped();
7459 if (UNLIKELY(state->argumentCount() < 1))
7460 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7461 auto command = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7462 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7463 auto argument = state->argument(1).isUndefined() ? 0 : convert<IDLUnrestrictedFloat>(*state, state->uncheckedArgument(1));
7464 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7465 propagateException(*state, throwScope, impl.postRemoteControlCommand(WTFMove(command), WTFMove(argument)));
7466 return JSValue::encode(jsUndefined());
7467}
7468
7469EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostRemoteControlCommand(ExecState* state)
7470{
7471 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPostRemoteControlCommandBody>(*state, "postRemoteControlCommand");
7472}
7473
7474#endif
7475
7476#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7477static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7478{
7479 UNUSED_PARAM(state);
7480 UNUSED_PARAM(throwScope);
7481 auto& impl = castedThis->wrapped();
7482 if (UNLIKELY(state->argumentCount() < 1))
7483 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7484 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7485 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7486 impl.setMockMediaPlaybackTargetPickerEnabled(WTFMove(enabled));
7487 return JSValue::encode(jsUndefined());
7488}
7489
7490EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabled(ExecState* state)
7491{
7492 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerEnabledBody>(*state, "setMockMediaPlaybackTargetPickerEnabled");
7493}
7494
7495#endif
7496
7497#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7498static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7499{
7500 UNUSED_PARAM(state);
7501 UNUSED_PARAM(throwScope);
7502 auto& impl = castedThis->wrapped();
7503 if (UNLIKELY(state->argumentCount() < 2))
7504 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7505 auto deviceName = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7506 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7507 auto deviceState = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7508 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7509 propagateException(*state, throwScope, impl.setMockMediaPlaybackTargetPickerState(WTFMove(deviceName), WTFMove(deviceState)));
7510 return JSValue::encode(jsUndefined());
7511}
7512
7513EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerState(ExecState* state)
7514{
7515 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaPlaybackTargetPickerStateBody>(*state, "setMockMediaPlaybackTargetPickerState");
7516}
7517
7518#endif
7519
7520#if ENABLE(MEDIA_STREAM)
7521static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7522{
7523 UNUSED_PARAM(state);
7524 UNUSED_PARAM(throwScope);
7525 auto& impl = castedThis->wrapped();
7526 if (UNLIKELY(state->argumentCount() < 1))
7527 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7528 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7529 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7530 impl.setMockMediaCaptureDevicesEnabled(WTFMove(enabled));
7531 return JSValue::encode(jsUndefined());
7532}
7533
7534EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabled(ExecState* state)
7535{
7536 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMockMediaCaptureDevicesEnabledBody>(*state, "setMockMediaCaptureDevicesEnabled");
7537}
7538
7539#endif
7540
7541#if ENABLE(MEDIA_STREAM)
7542static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreatorBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7543{
7544 UNUSED_PARAM(state);
7545 UNUSED_PARAM(throwScope);
7546 auto& impl = castedThis->wrapped();
7547 impl.setCustomPrivateRecorderCreator();
7548 return JSValue::encode(jsUndefined());
7549}
7550
7551EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreator(ExecState* state)
7552{
7553 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCustomPrivateRecorderCreatorBody>(*state, "setCustomPrivateRecorderCreator");
7554}
7555
7556#endif
7557
7558#if ENABLE(WEB_RTC)
7559static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEventBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7560{
7561 UNUSED_PARAM(state);
7562 UNUSED_PARAM(throwScope);
7563 auto& impl = castedThis->wrapped();
7564 if (UNLIKELY(state->argumentCount() < 2))
7565 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7566 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "emulateRTCPeerConnectionPlatformEvent", "RTCPeerConnection"); });
7567 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7568 auto action = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
7569 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7570 impl.emulateRTCPeerConnectionPlatformEvent(*connection, WTFMove(action));
7571 return JSValue::encode(jsUndefined());
7572}
7573
7574EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEvent(ExecState* state)
7575{
7576 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionEmulateRTCPeerConnectionPlatformEventBody>(*state, "emulateRTCPeerConnectionPlatformEvent");
7577}
7578
7579#endif
7580
7581#if ENABLE(WEB_RTC)
7582static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7583{
7584 UNUSED_PARAM(state);
7585 UNUSED_PARAM(throwScope);
7586 auto& impl = castedThis->wrapped();
7587 if (UNLIKELY(state->argumentCount() < 1))
7588 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7589 auto testCase = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7590 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7591 impl.useMockRTCPeerConnectionFactory(WTFMove(testCase));
7592 return JSValue::encode(jsUndefined());
7593}
7594
7595EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactory(ExecState* state)
7596{
7597 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUseMockRTCPeerConnectionFactoryBody>(*state, "useMockRTCPeerConnectionFactory");
7598}
7599
7600#endif
7601
7602#if ENABLE(WEB_RTC)
7603static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetICECandidateFilteringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7604{
7605 UNUSED_PARAM(state);
7606 UNUSED_PARAM(throwScope);
7607 auto& impl = castedThis->wrapped();
7608 if (UNLIKELY(state->argumentCount() < 1))
7609 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7610 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7611 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7612 impl.setICECandidateFiltering(WTFMove(enabled));
7613 return JSValue::encode(jsUndefined());
7614}
7615
7616EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetICECandidateFiltering(ExecState* state)
7617{
7618 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetICECandidateFilteringBody>(*state, "setICECandidateFiltering");
7619}
7620
7621#endif
7622
7623#if ENABLE(WEB_RTC)
7624static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7625{
7626 UNUSED_PARAM(state);
7627 UNUSED_PARAM(throwScope);
7628 auto& impl = castedThis->wrapped();
7629 if (UNLIKELY(state->argumentCount() < 1))
7630 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7631 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7632 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7633 impl.setEnumeratingAllNetworkInterfacesEnabled(WTFMove(enabled));
7634 return JSValue::encode(jsUndefined());
7635}
7636
7637EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabled(ExecState* state)
7638{
7639 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetEnumeratingAllNetworkInterfacesEnabledBody>(*state, "setEnumeratingAllNetworkInterfacesEnabled");
7640}
7641
7642#endif
7643
7644#if ENABLE(WEB_RTC)
7645static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionStopPeerConnectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7646{
7647 UNUSED_PARAM(state);
7648 UNUSED_PARAM(throwScope);
7649 auto& impl = castedThis->wrapped();
7650 if (UNLIKELY(state->argumentCount() < 1))
7651 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7652 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "stopPeerConnection", "RTCPeerConnection"); });
7653 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7654 impl.stopPeerConnection(*connection);
7655 return JSValue::encode(jsUndefined());
7656}
7657
7658EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionStopPeerConnection(ExecState* state)
7659{
7660 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionStopPeerConnectionBody>(*state, "stopPeerConnection");
7661}
7662
7663#endif
7664
7665#if ENABLE(WEB_RTC)
7666static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearPeerConnectionFactoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7667{
7668 UNUSED_PARAM(state);
7669 UNUSED_PARAM(throwScope);
7670 auto& impl = castedThis->wrapped();
7671 impl.clearPeerConnectionFactory();
7672 return JSValue::encode(jsUndefined());
7673}
7674
7675EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearPeerConnectionFactory(ExecState* state)
7676{
7677 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionClearPeerConnectionFactoryBody>(*state, "clearPeerConnectionFactory");
7678}
7679
7680#endif
7681
7682#if ENABLE(VIDEO)
7683static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateSystemSleepBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7684{
7685 UNUSED_PARAM(state);
7686 UNUSED_PARAM(throwScope);
7687 auto& impl = castedThis->wrapped();
7688 impl.simulateSystemSleep();
7689 return JSValue::encode(jsUndefined());
7690}
7691
7692EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemSleep(ExecState* state)
7693{
7694 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateSystemSleepBody>(*state, "simulateSystemSleep");
7695}
7696
7697#endif
7698
7699#if ENABLE(VIDEO)
7700static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateSystemWakeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7701{
7702 UNUSED_PARAM(state);
7703 UNUSED_PARAM(throwScope);
7704 auto& impl = castedThis->wrapped();
7705 impl.simulateSystemWake();
7706 return JSValue::encode(jsUndefined());
7707}
7708
7709EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateSystemWake(ExecState* state)
7710{
7711 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateSystemWakeBody>(*state, "simulateSystemWake");
7712}
7713
7714#endif
7715
7716#if ENABLE(VIDEO)
7717static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionElementIsBlockingDisplaySleepBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7718{
7719 UNUSED_PARAM(state);
7720 UNUSED_PARAM(throwScope);
7721 auto& impl = castedThis->wrapped();
7722 if (UNLIKELY(state->argumentCount() < 1))
7723 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7724 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "elementIsBlockingDisplaySleep", "HTMLMediaElement"); });
7725 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7726 return JSValue::encode(toJS<IDLBoolean>(impl.elementIsBlockingDisplaySleep(*element)));
7727}
7728
7729EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionElementIsBlockingDisplaySleep(ExecState* state)
7730{
7731 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionElementIsBlockingDisplaySleepBody>(*state, "elementIsBlockingDisplaySleep");
7732}
7733
7734#endif
7735
7736static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionInstallMockPageOverlayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7737{
7738 UNUSED_PARAM(state);
7739 UNUSED_PARAM(throwScope);
7740 auto& impl = castedThis->wrapped();
7741 if (UNLIKELY(state->argumentCount() < 1))
7742 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7743 auto type = convert<IDLEnumeration<Internals::PageOverlayType>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "type", "Internals", "installMockPageOverlay", expectedEnumerationValues<Internals::PageOverlayType>()); });
7744 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7745 return JSValue::encode(toJS<IDLInterface<MockPageOverlay>>(*state, *castedThis->globalObject(), throwScope, impl.installMockPageOverlay(WTFMove(type))));
7746}
7747
7748EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionInstallMockPageOverlay(ExecState* state)
7749{
7750 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionInstallMockPageOverlayBody>(*state, "installMockPageOverlay");
7751}
7752
7753static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageOverlayLayerTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7754{
7755 UNUSED_PARAM(state);
7756 UNUSED_PARAM(throwScope);
7757 auto& impl = castedThis->wrapped();
7758 auto flags = convert<IDLUnsignedShort>(*state, state->argument(0));
7759 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7760 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pageOverlayLayerTreeAsText(WTFMove(flags))));
7761}
7762
7763EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageOverlayLayerTreeAsText(ExecState* state)
7764{
7765 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageOverlayLayerTreeAsTextBody>(*state, "pageOverlayLayerTreeAsText");
7766}
7767
7768static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageMutedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7769{
7770 UNUSED_PARAM(state);
7771 UNUSED_PARAM(throwScope);
7772 auto& impl = castedThis->wrapped();
7773 if (UNLIKELY(state->argumentCount() < 1))
7774 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7775 auto mutedState = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7776 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7777 impl.setPageMuted(WTFMove(mutedState));
7778 return JSValue::encode(jsUndefined());
7779}
7780
7781EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageMuted(ExecState* state)
7782{
7783 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageMutedBody>(*state, "setPageMuted");
7784}
7785
7786static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageMediaStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7787{
7788 UNUSED_PARAM(state);
7789 UNUSED_PARAM(throwScope);
7790 auto& impl = castedThis->wrapped();
7791 return JSValue::encode(toJS<IDLDOMString>(*state, impl.pageMediaState()));
7792}
7793
7794EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageMediaState(ExecState* state)
7795{
7796 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageMediaStateBody>(*state, "pageMediaState");
7797}
7798
7799static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageDefersLoadingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7800{
7801 UNUSED_PARAM(state);
7802 UNUSED_PARAM(throwScope);
7803 auto& impl = castedThis->wrapped();
7804 if (UNLIKELY(state->argumentCount() < 1))
7805 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7806 auto defersLoading = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7807 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7808 impl.setPageDefersLoading(WTFMove(defersLoading));
7809 return JSValue::encode(jsUndefined());
7810}
7811
7812EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageDefersLoading(ExecState* state)
7813{
7814 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageDefersLoadingBody>(*state, "setPageDefersLoading");
7815}
7816
7817static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageDefersLoadingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7818{
7819 UNUSED_PARAM(state);
7820 UNUSED_PARAM(throwScope);
7821 auto& impl = castedThis->wrapped();
7822 return JSValue::encode(toJS<IDLBoolean>(*state, throwScope, impl.pageDefersLoading()));
7823}
7824
7825EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageDefersLoading(ExecState* state)
7826{
7827 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageDefersLoadingBody>(*state, "pageDefersLoading");
7828}
7829
7830static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCreateFileBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7831{
7832 UNUSED_PARAM(state);
7833 UNUSED_PARAM(throwScope);
7834 auto& impl = castedThis->wrapped();
7835 if (UNLIKELY(state->argumentCount() < 1))
7836 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7837 auto url = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
7838 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7839 return JSValue::encode(toJS<IDLNullable<IDLInterface<File>>>(*state, *castedThis->globalObject(), impl.createFile(WTFMove(url))));
7840}
7841
7842EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCreateFile(ExecState* state)
7843{
7844 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCreateFileBody>(*state, "createFile");
7845}
7846
7847static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionQueueMicroTaskBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7848{
7849 UNUSED_PARAM(state);
7850 UNUSED_PARAM(throwScope);
7851 auto& impl = castedThis->wrapped();
7852 if (UNLIKELY(state->argumentCount() < 1))
7853 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7854 auto testNumber = convert<IDLLong>(*state, state->uncheckedArgument(0));
7855 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7856 impl.queueMicroTask(WTFMove(testNumber));
7857 return JSValue::encode(jsUndefined());
7858}
7859
7860EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionQueueMicroTask(ExecState* state)
7861{
7862 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionQueueMicroTaskBody>(*state, "queueMicroTask");
7863}
7864
7865static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTestPreloaderSettingViewportBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7866{
7867 UNUSED_PARAM(state);
7868 UNUSED_PARAM(throwScope);
7869 auto& impl = castedThis->wrapped();
7870 return JSValue::encode(toJS<IDLBoolean>(impl.testPreloaderSettingViewport()));
7871}
7872
7873EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestPreloaderSettingViewport(ExecState* state)
7874{
7875 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTestPreloaderSettingViewportBody>(*state, "testPreloaderSettingViewport");
7876}
7877
7878#if ENABLE(CSS_SCROLL_SNAP)
7879static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionScrollSnapOffsetsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7880{
7881 UNUSED_PARAM(state);
7882 UNUSED_PARAM(throwScope);
7883 auto& impl = castedThis->wrapped();
7884 if (UNLIKELY(state->argumentCount() < 1))
7885 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7886 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "scrollSnapOffsets", "Element"); });
7887 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7888 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.scrollSnapOffsets(*element)));
7889}
7890
7891EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionScrollSnapOffsets(ExecState* state)
7892{
7893 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionScrollSnapOffsetsBody>(*state, "scrollSnapOffsets");
7894}
7895
7896#endif
7897
7898#if ENABLE(CSS_SCROLL_SNAP)
7899static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7900{
7901 UNUSED_PARAM(state);
7902 UNUSED_PARAM(throwScope);
7903 auto& impl = castedThis->wrapped();
7904 if (UNLIKELY(state->argumentCount() < 1))
7905 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7906 auto enabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7907 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7908 impl.setPlatformMomentumScrollingPredictionEnabled(WTFMove(enabled));
7909 return JSValue::encode(jsUndefined());
7910}
7911
7912EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabled(ExecState* state)
7913{
7914 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPlatformMomentumScrollingPredictionEnabledBody>(*state, "setPlatformMomentumScrollingPredictionEnabled");
7915}
7916
7917#endif
7918
7919static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRectsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7920{
7921 UNUSED_PARAM(state);
7922 UNUSED_PARAM(throwScope);
7923 auto& impl = castedThis->wrapped();
7924 if (UNLIKELY(state->argumentCount() < 2))
7925 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7926 auto rectComponents = convert<IDLSequence<IDLDouble>>(*state, state->uncheckedArgument(0));
7927 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7928 auto radius = convert<IDLDouble>(*state, state->uncheckedArgument(1));
7929 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7930 return JSValue::encode(toJS<IDLDOMString>(*state, throwScope, impl.pathStringWithShrinkWrappedRects(WTFMove(rectComponents), WTFMove(radius))));
7931}
7932
7933EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRects(ExecState* state)
7934{
7935 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPathStringWithShrinkWrappedRectsBody>(*state, "pathStringWithShrinkWrappedRects");
7936}
7937
7938#if ENABLE(VIDEO)
7939static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElementBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7940{
7941 UNUSED_PARAM(state);
7942 UNUSED_PARAM(throwScope);
7943 auto& impl = castedThis->wrapped();
7944 if (UNLIKELY(state->argumentCount() < 1))
7945 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7946 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "getCurrentMediaControlsStatusForElement", "HTMLMediaElement"); });
7947 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7948 return JSValue::encode(toJS<IDLDOMString>(*state, impl.getCurrentMediaControlsStatusForElement(*element)));
7949}
7950
7951EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElement(ExecState* state)
7952{
7953 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCurrentMediaControlsStatusForElementBody>(*state, "getCurrentMediaControlsStatusForElement");
7954}
7955
7956#endif
7957
7958static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserVisibleStringBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7959{
7960 UNUSED_PARAM(state);
7961 UNUSED_PARAM(throwScope);
7962 auto& impl = castedThis->wrapped();
7963 if (UNLIKELY(state->argumentCount() < 1))
7964 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7965 auto url = convert<IDLInterface<DOMURL>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "url", "Internals", "userVisibleString", "DOMURL"); });
7966 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7967 return JSValue::encode(toJS<IDLDOMString>(*state, impl.userVisibleString(*url)));
7968}
7969
7970EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserVisibleString(ExecState* state)
7971{
7972 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserVisibleStringBody>(*state, "userVisibleString");
7973}
7974
7975static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetShowAllPluginsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7976{
7977 UNUSED_PARAM(state);
7978 UNUSED_PARAM(throwScope);
7979 auto& impl = castedThis->wrapped();
7980 if (UNLIKELY(state->argumentCount() < 1))
7981 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
7982 auto showAll = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
7983 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
7984 impl.setShowAllPlugins(WTFMove(showAll));
7985 return JSValue::encode(jsUndefined());
7986}
7987
7988EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetShowAllPlugins(ExecState* state)
7989{
7990 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetShowAllPluginsBody>(*state, "setShowAllPlugins");
7991}
7992
7993#if ENABLE(STREAMS_API)
7994static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCloneArrayBufferBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
7995{
7996 UNUSED_PARAM(state);
7997 UNUSED_PARAM(throwScope);
7998 auto& impl = castedThis->wrapped();
7999 if (UNLIKELY(state->argumentCount() < 3))
8000 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8001 auto buffer = convert<IDLAny>(*state, state->uncheckedArgument(0));
8002 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8003 auto srcByteOffset = convert<IDLAny>(*state, state->uncheckedArgument(1));
8004 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8005 auto byteLength = convert<IDLAny>(*state, state->uncheckedArgument(2));
8006 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8007 return JSValue::encode(toJS<IDLAny>(impl.cloneArrayBuffer(*state, WTFMove(buffer), WTFMove(srcByteOffset), WTFMove(byteLength))));
8008}
8009
8010EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCloneArrayBuffer(ExecState* state)
8011{
8012 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCloneArrayBufferBody>(*state, "cloneArrayBuffer");
8013}
8014
8015#endif
8016
8017#if ENABLE(STREAMS_API)
8018static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsReadableStreamDisturbedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8019{
8020 UNUSED_PARAM(state);
8021 UNUSED_PARAM(throwScope);
8022 auto& impl = castedThis->wrapped();
8023 if (UNLIKELY(state->argumentCount() < 1))
8024 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8025 auto stream = convert<IDLAny>(*state, state->uncheckedArgument(0));
8026 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8027 return JSValue::encode(toJS<IDLBoolean>(impl.isReadableStreamDisturbed(*state, WTFMove(stream))));
8028}
8029
8030EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsReadableStreamDisturbed(ExecState* state)
8031{
8032 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsReadableStreamDisturbedBody>(*state, "isReadableStreamDisturbed");
8033}
8034
8035#endif
8036
8037static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResourceLoadStatisticsForURLBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8038{
8039 UNUSED_PARAM(state);
8040 UNUSED_PARAM(throwScope);
8041 auto& impl = castedThis->wrapped();
8042 if (UNLIKELY(state->argumentCount() < 1))
8043 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8044 auto url = convert<IDLInterface<DOMURL>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "url", "Internals", "resourceLoadStatisticsForURL", "DOMURL"); });
8045 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8046 return JSValue::encode(toJS<IDLDOMString>(*state, impl.resourceLoadStatisticsForURL(*url)));
8047}
8048
8049EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResourceLoadStatisticsForURL(ExecState* state)
8050{
8051 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResourceLoadStatisticsForURLBody>(*state, "resourceLoadStatisticsForURL");
8052}
8053
8054static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8055{
8056 UNUSED_PARAM(state);
8057 UNUSED_PARAM(throwScope);
8058 auto& impl = castedThis->wrapped();
8059 if (UNLIKELY(state->argumentCount() < 1))
8060 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8061 auto enable = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8062 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8063 impl.setResourceLoadStatisticsEnabled(WTFMove(enable));
8064 return JSValue::encode(jsUndefined());
8065}
8066
8067EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabled(ExecState* state)
8068{
8069 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetResourceLoadStatisticsEnabledBody>(*state, "setResourceLoadStatisticsEnabled");
8070}
8071
8072static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCanShowModalDialogOverrideBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8073{
8074 UNUSED_PARAM(state);
8075 UNUSED_PARAM(throwScope);
8076 auto& impl = castedThis->wrapped();
8077 if (UNLIKELY(state->argumentCount() < 1))
8078 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8079 auto allow = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8080 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8081 propagateException(*state, throwScope, impl.setCanShowModalDialogOverride(WTFMove(allow)));
8082 return JSValue::encode(jsUndefined());
8083}
8084
8085EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCanShowModalDialogOverride(ExecState* state)
8086{
8087 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCanShowModalDialogOverrideBody>(*state, "setCanShowModalDialogOverride");
8088}
8089
8090static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionComposedTreeAsTextBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8091{
8092 UNUSED_PARAM(state);
8093 UNUSED_PARAM(throwScope);
8094 auto& impl = castedThis->wrapped();
8095 if (UNLIKELY(state->argumentCount() < 1))
8096 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8097 auto parent = convert<IDLInterface<Node>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "parent", "Internals", "composedTreeAsText", "Node"); });
8098 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8099 return JSValue::encode(toJS<IDLDOMString>(*state, impl.composedTreeAsText(*parent)));
8100}
8101
8102EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionComposedTreeAsText(ExecState* state)
8103{
8104 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionComposedTreeAsTextBody>(*state, "composedTreeAsText");
8105}
8106
8107static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsProcessingUserGestureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8108{
8109 UNUSED_PARAM(state);
8110 UNUSED_PARAM(throwScope);
8111 auto& impl = castedThis->wrapped();
8112 return JSValue::encode(toJS<IDLBoolean>(impl.isProcessingUserGesture()));
8113}
8114
8115EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsProcessingUserGesture(ExecState* state)
8116{
8117 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsProcessingUserGestureBody>(*state, "isProcessingUserGesture");
8118}
8119
8120static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionLastHandledUserGestureTimestampBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8121{
8122 UNUSED_PARAM(state);
8123 UNUSED_PARAM(throwScope);
8124 auto& impl = castedThis->wrapped();
8125 return JSValue::encode(toJS<IDLDouble>(impl.lastHandledUserGestureTimestamp()));
8126}
8127
8128EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionLastHandledUserGestureTimestamp(ExecState* state)
8129{
8130 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionLastHandledUserGestureTimestampBody>(*state, "lastHandledUserGestureTimestamp");
8131}
8132
8133static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionWithUserGestureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8134{
8135 UNUSED_PARAM(state);
8136 UNUSED_PARAM(throwScope);
8137 auto& impl = castedThis->wrapped();
8138 if (UNLIKELY(state->argumentCount() < 1))
8139 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8140 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "withUserGesture"); });
8141 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8142 impl.withUserGesture(callback.releaseNonNull());
8143 return JSValue::encode(jsUndefined());
8144}
8145
8146EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionWithUserGesture(ExecState* state)
8147{
8148 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionWithUserGestureBody>(*state, "withUserGesture");
8149}
8150
8151static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserIsInteractingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8152{
8153 UNUSED_PARAM(state);
8154 UNUSED_PARAM(throwScope);
8155 auto& impl = castedThis->wrapped();
8156 return JSValue::encode(toJS<IDLBoolean>(impl.userIsInteracting()));
8157}
8158
8159EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserIsInteracting(ExecState* state)
8160{
8161 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserIsInteractingBody>(*state, "userIsInteracting");
8162}
8163
8164static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionObserveGCBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8165{
8166 UNUSED_PARAM(state);
8167 UNUSED_PARAM(throwScope);
8168 auto& impl = castedThis->wrapped();
8169 if (UNLIKELY(state->argumentCount() < 1))
8170 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8171 auto observed = convert<IDLAny>(*state, state->uncheckedArgument(0));
8172 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8173 return JSValue::encode(toJS<IDLNullable<IDLInterface<GCObservation>>>(*state, *castedThis->globalObject(), impl.observeGC(WTFMove(observed))));
8174}
8175
8176EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveGC(ExecState* state)
8177{
8178 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionObserveGCBody>(*state, "observeGC");
8179}
8180
8181static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8182{
8183 UNUSED_PARAM(state);
8184 UNUSED_PARAM(throwScope);
8185 auto& impl = castedThis->wrapped();
8186 if (UNLIKELY(state->argumentCount() < 1))
8187 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8188 auto userInterfaceLayoutDirection = convert<IDLEnumeration<Internals::UserInterfaceLayoutDirection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "userInterfaceLayoutDirection", "Internals", "setUserInterfaceLayoutDirection", expectedEnumerationValues<Internals::UserInterfaceLayoutDirection>()); });
8189 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8190 impl.setUserInterfaceLayoutDirection(WTFMove(userInterfaceLayoutDirection));
8191 return JSValue::encode(jsUndefined());
8192}
8193
8194EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirection(ExecState* state)
8195{
8196 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUserInterfaceLayoutDirectionBody>(*state, "setUserInterfaceLayoutDirection");
8197}
8198
8199static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetBaseWritingDirectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8200{
8201 UNUSED_PARAM(state);
8202 UNUSED_PARAM(throwScope);
8203 auto& impl = castedThis->wrapped();
8204 if (UNLIKELY(state->argumentCount() < 1))
8205 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8206 auto direction = convert<IDLEnumeration<Internals::BaseWritingDirection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "direction", "Internals", "setBaseWritingDirection", expectedEnumerationValues<Internals::BaseWritingDirection>()); });
8207 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8208 impl.setBaseWritingDirection(WTFMove(direction));
8209 return JSValue::encode(jsUndefined());
8210}
8211
8212EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetBaseWritingDirection(ExecState* state)
8213{
8214 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetBaseWritingDirectionBody>(*state, "setBaseWritingDirection");
8215}
8216
8217static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUserPrefersReducedMotionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8218{
8219 UNUSED_PARAM(state);
8220 UNUSED_PARAM(throwScope);
8221 auto& impl = castedThis->wrapped();
8222 return JSValue::encode(toJS<IDLBoolean>(impl.userPrefersReducedMotion()));
8223}
8224
8225EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUserPrefersReducedMotion(ExecState* state)
8226{
8227 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUserPrefersReducedMotionBody>(*state, "userPrefersReducedMotion");
8228}
8229
8230static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReportBacktraceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8231{
8232 UNUSED_PARAM(state);
8233 UNUSED_PARAM(throwScope);
8234 auto& impl = castedThis->wrapped();
8235 impl.reportBacktrace();
8236 return JSValue::encode(jsUndefined());
8237}
8238
8239EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReportBacktrace(ExecState* state)
8240{
8241 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReportBacktraceBody>(*state, "reportBacktrace");
8242}
8243
8244#if ENABLE(POINTER_LOCK)
8245static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageHasPendingPointerLockBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8246{
8247 UNUSED_PARAM(state);
8248 UNUSED_PARAM(throwScope);
8249 auto& impl = castedThis->wrapped();
8250 return JSValue::encode(toJS<IDLBoolean>(impl.pageHasPendingPointerLock()));
8251}
8252
8253EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPendingPointerLock(ExecState* state)
8254{
8255 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageHasPendingPointerLockBody>(*state, "pageHasPendingPointerLock");
8256}
8257
8258#endif
8259
8260#if ENABLE(POINTER_LOCK)
8261static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPageHasPointerLockBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8262{
8263 UNUSED_PARAM(state);
8264 UNUSED_PARAM(throwScope);
8265 auto& impl = castedThis->wrapped();
8266 return JSValue::encode(toJS<IDLBoolean>(impl.pageHasPointerLock()));
8267}
8268
8269EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPageHasPointerLock(ExecState* state)
8270{
8271 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPageHasPointerLockBody>(*state, "pageHasPointerLock");
8272}
8273
8274#endif
8275
8276static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAccessKeyModifiersBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8277{
8278 UNUSED_PARAM(state);
8279 UNUSED_PARAM(throwScope);
8280 auto& impl = castedThis->wrapped();
8281 return JSValue::encode(toJS<IDLSequence<IDLDOMString>>(*state, *castedThis->globalObject(), impl.accessKeyModifiers()));
8282}
8283
8284EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAccessKeyModifiers(ExecState* state)
8285{
8286 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAccessKeyModifiersBody>(*state, "accessKeyModifiers");
8287}
8288
8289static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetQuickLookPasswordBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8290{
8291 UNUSED_PARAM(state);
8292 UNUSED_PARAM(throwScope);
8293 auto& impl = castedThis->wrapped();
8294 if (UNLIKELY(state->argumentCount() < 1))
8295 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8296 auto password = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
8297 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8298 impl.setQuickLookPassword(WTFMove(password));
8299 return JSValue::encode(jsUndefined());
8300}
8301
8302EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetQuickLookPassword(ExecState* state)
8303{
8304 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetQuickLookPasswordBody>(*state, "setQuickLookPassword");
8305}
8306
8307static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAsRunningUserScriptsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8308{
8309 UNUSED_PARAM(state);
8310 UNUSED_PARAM(throwScope);
8311 auto& impl = castedThis->wrapped();
8312 auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
8313 if (UNLIKELY(!context))
8314 return JSValue::encode(jsUndefined());
8315 ASSERT(context->isDocument());
8316 auto& document = downcast<Document>(*context);
8317 impl.setAsRunningUserScripts(document);
8318 return JSValue::encode(jsUndefined());
8319}
8320
8321EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAsRunningUserScripts(ExecState* state)
8322{
8323 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAsRunningUserScriptsBody>(*state, "setAsRunningUserScripts");
8324}
8325
8326#if ENABLE(APPLE_PAY)
8327static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetHasStartedApplePaySessionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8328{
8329 UNUSED_PARAM(state);
8330 UNUSED_PARAM(throwScope);
8331 auto& impl = castedThis->wrapped();
8332 auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
8333 if (UNLIKELY(!context))
8334 return JSValue::encode(jsUndefined());
8335 ASSERT(context->isDocument());
8336 auto& document = downcast<Document>(*context);
8337 impl.setHasStartedApplePaySession(document);
8338 return JSValue::encode(jsUndefined());
8339}
8340
8341EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetHasStartedApplePaySession(ExecState* state)
8342{
8343 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetHasStartedApplePaySessionBody>(*state, "setHasStartedApplePaySession");
8344}
8345
8346#endif
8347
8348static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDisableTileSizeUpdateDelayBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8349{
8350 UNUSED_PARAM(state);
8351 UNUSED_PARAM(throwScope);
8352 auto& impl = castedThis->wrapped();
8353 impl.disableTileSizeUpdateDelay();
8354 return JSValue::encode(jsUndefined());
8355}
8356
8357EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDisableTileSizeUpdateDelay(ExecState* state)
8358{
8359 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDisableTileSizeUpdateDelayBody>(*state, "disableTileSizeUpdateDelay");
8360}
8361
8362static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTestingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8363{
8364 UNUSED_PARAM(state);
8365 UNUSED_PARAM(throwScope);
8366 auto& impl = castedThis->wrapped();
8367 if (UNLIKELY(state->argumentCount() < 1))
8368 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8369 auto disabled = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8370 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8371 impl.setSpeculativeTilingDelayDisabledForTesting(WTFMove(disabled));
8372 return JSValue::encode(jsUndefined());
8373}
8374
8375EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTesting(ExecState* state)
8376{
8377 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetSpeculativeTilingDelayDisabledForTestingBody>(*state, "setSpeculativeTilingDelayDisabledForTesting");
8378}
8379
8380#if ENABLE(WEBGL)
8381static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateWebGLContextChangedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8382{
8383 UNUSED_PARAM(state);
8384 UNUSED_PARAM(throwScope);
8385 auto& impl = castedThis->wrapped();
8386 if (UNLIKELY(state->argumentCount() < 1))
8387 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8388 auto context = convert<IDLInterface<WebGLRenderingContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "simulateWebGLContextChanged", "WebGLRenderingContext"); });
8389 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8390 impl.simulateWebGLContextChanged(*context);
8391 return JSValue::encode(jsUndefined());
8392}
8393
8394EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateWebGLContextChanged(ExecState* state)
8395{
8396 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateWebGLContextChangedBody>(*state, "simulateWebGLContextChanged");
8397}
8398
8399#endif
8400
8401#if ENABLE(WEBGL)
8402static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionFailNextGPUStatusCheckBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8403{
8404 UNUSED_PARAM(state);
8405 UNUSED_PARAM(throwScope);
8406 auto& impl = castedThis->wrapped();
8407 if (UNLIKELY(state->argumentCount() < 1))
8408 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8409 auto context = convert<IDLInterface<WebGLRenderingContext>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "context", "Internals", "failNextGPUStatusCheck", "WebGLRenderingContext"); });
8410 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8411 impl.failNextGPUStatusCheck(*context);
8412 return JSValue::encode(jsUndefined());
8413}
8414
8415EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionFailNextGPUStatusCheck(ExecState* state)
8416{
8417 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionFailNextGPUStatusCheckBody>(*state, "failNextGPUStatusCheck");
8418}
8419
8420#endif
8421
8422#if ENABLE(WEBGL)
8423static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasLowAndHighPowerGPUsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8424{
8425 UNUSED_PARAM(state);
8426 UNUSED_PARAM(throwScope);
8427 auto& impl = castedThis->wrapped();
8428 return JSValue::encode(toJS<IDLBoolean>(impl.hasLowAndHighPowerGPUs()));
8429}
8430
8431EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasLowAndHighPowerGPUs(ExecState* state)
8432{
8433 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasLowAndHighPowerGPUsBody>(*state, "hasLowAndHighPowerGPUs");
8434}
8435
8436#endif
8437
8438static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageVisibilityBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8439{
8440 UNUSED_PARAM(state);
8441 UNUSED_PARAM(throwScope);
8442 auto& impl = castedThis->wrapped();
8443 if (UNLIKELY(state->argumentCount() < 1))
8444 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8445 auto isVisible = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8446 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8447 impl.setPageVisibility(WTFMove(isVisible));
8448 return JSValue::encode(jsUndefined());
8449}
8450
8451EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageVisibility(ExecState* state)
8452{
8453 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageVisibilityBody>(*state, "setPageVisibility");
8454}
8455
8456static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetPageIsFocusedAndActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8457{
8458 UNUSED_PARAM(state);
8459 UNUSED_PARAM(throwScope);
8460 auto& impl = castedThis->wrapped();
8461 if (UNLIKELY(state->argumentCount() < 1))
8462 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8463 auto isFocused = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8464 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8465 impl.setPageIsFocusedAndActive(WTFMove(isFocused));
8466 return JSValue::encode(jsUndefined());
8467}
8468
8469EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetPageIsFocusedAndActive(ExecState* state)
8470{
8471 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetPageIsFocusedAndActiveBody>(*state, "setPageIsFocusedAndActive");
8472}
8473
8474#if ENABLE(WEB_RTC)
8475static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8476{
8477 UNUSED_PARAM(state);
8478 UNUSED_PARAM(throwScope);
8479 auto& impl = castedThis->wrapped();
8480 if (UNLIKELY(state->argumentCount() < 1))
8481 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8482 auto allowed = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8483 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8484 impl.setH264HardwareEncoderAllowed(WTFMove(allowed));
8485 return JSValue::encode(jsUndefined());
8486}
8487
8488EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowed(ExecState* state)
8489{
8490 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetH264HardwareEncoderAllowedBody>(*state, "setH264HardwareEncoderAllowed");
8491}
8492
8493#endif
8494
8495#if ENABLE(WEB_RTC)
8496static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSourcesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8497{
8498 UNUSED_PARAM(state);
8499 UNUSED_PARAM(throwScope);
8500 auto& impl = castedThis->wrapped();
8501 if (UNLIKELY(state->argumentCount() < 1))
8502 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8503 auto connection = convert<IDLInterface<RTCPeerConnection>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "connection", "Internals", "applyRotationForOutgoingVideoSources", "RTCPeerConnection"); });
8504 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8505 impl.applyRotationForOutgoingVideoSources(*connection);
8506 return JSValue::encode(jsUndefined());
8507}
8508
8509EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSources(ExecState* state)
8510{
8511 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionApplyRotationForOutgoingVideoSourcesBody>(*state, "applyRotationForOutgoingVideoSources");
8512}
8513
8514#endif
8515
8516#if ENABLE(MEDIA_STREAM)
8517static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientationBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8518{
8519 UNUSED_PARAM(state);
8520 UNUSED_PARAM(throwScope);
8521 auto& impl = castedThis->wrapped();
8522 if (UNLIKELY(state->argumentCount() < 2))
8523 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8524 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setCameraMediaStreamTrackOrientation", "MediaStreamTrack"); });
8525 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8526 auto orientation = convert<IDLShort>(*state, state->uncheckedArgument(1));
8527 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8528 impl.setCameraMediaStreamTrackOrientation(*track, WTFMove(orientation));
8529 return JSValue::encode(jsUndefined());
8530}
8531
8532EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientation(ExecState* state)
8533{
8534 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCameraMediaStreamTrackOrientationBody>(*state, "setCameraMediaStreamTrackOrientation");
8535}
8536
8537#endif
8538
8539#if ENABLE(MEDIA_STREAM)
8540static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionObserveMediaStreamTrackBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8541{
8542 UNUSED_PARAM(state);
8543 UNUSED_PARAM(throwScope);
8544 auto& impl = castedThis->wrapped();
8545 if (UNLIKELY(state->argumentCount() < 1))
8546 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8547 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "observeMediaStreamTrack", "MediaStreamTrack"); });
8548 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8549 impl.observeMediaStreamTrack(*track);
8550 return JSValue::encode(jsUndefined());
8551}
8552
8553EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionObserveMediaStreamTrack(ExecState* state)
8554{
8555 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionObserveMediaStreamTrackBody>(*state, "observeMediaStreamTrack");
8556}
8557
8558#endif
8559
8560#if ENABLE(MEDIA_STREAM)
8561static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrameBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8562{
8563 UNUSED_PARAM(state);
8564 UNUSED_PARAM(throwScope);
8565 auto& impl = castedThis->wrapped();
8566 impl.grabNextMediaStreamTrackFrame(WTFMove(promise));
8567 return JSValue::encode(jsUndefined());
8568}
8569
8570EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrame(ExecState* state)
8571{
8572 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionGrabNextMediaStreamTrackFrameBody, PromiseExecutionScope::WindowOnly>(*state, "grabNextMediaStreamTrackFrame");
8573}
8574
8575#endif
8576
8577#if ENABLE(MEDIA_STREAM)
8578static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDelayMediaStreamTrackSamplesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8579{
8580 UNUSED_PARAM(state);
8581 UNUSED_PARAM(throwScope);
8582 auto& impl = castedThis->wrapped();
8583 if (UNLIKELY(state->argumentCount() < 2))
8584 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8585 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "delayMediaStreamTrackSamples", "MediaStreamTrack"); });
8586 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8587 auto delay = convert<IDLFloat>(*state, state->uncheckedArgument(1));
8588 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8589 impl.delayMediaStreamTrackSamples(*track, WTFMove(delay));
8590 return JSValue::encode(jsUndefined());
8591}
8592
8593EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDelayMediaStreamTrackSamples(ExecState* state)
8594{
8595 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDelayMediaStreamTrackSamplesBody>(*state, "delayMediaStreamTrackSamples");
8596}
8597
8598#endif
8599
8600#if ENABLE(MEDIA_STREAM)
8601static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamTrackMutedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8602{
8603 UNUSED_PARAM(state);
8604 UNUSED_PARAM(throwScope);
8605 auto& impl = castedThis->wrapped();
8606 if (UNLIKELY(state->argumentCount() < 2))
8607 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8608 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamTrackMuted", "MediaStreamTrack"); });
8609 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8610 auto muted = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
8611 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8612 impl.setMediaStreamTrackMuted(*track, WTFMove(muted));
8613 return JSValue::encode(jsUndefined());
8614}
8615
8616EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackMuted(ExecState* state)
8617{
8618 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamTrackMutedBody>(*state, "setMediaStreamTrackMuted");
8619}
8620
8621#endif
8622
8623#if ENABLE(MEDIA_STREAM)
8624static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionRemoveMediaStreamTrackBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8625{
8626 UNUSED_PARAM(state);
8627 UNUSED_PARAM(throwScope);
8628 auto& impl = castedThis->wrapped();
8629 if (UNLIKELY(state->argumentCount() < 2))
8630 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8631 auto stream = convert<IDLInterface<MediaStream>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "stream", "Internals", "removeMediaStreamTrack", "MediaStream"); });
8632 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8633 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(1), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 1, "track", "Internals", "removeMediaStreamTrack", "MediaStreamTrack"); });
8634 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8635 impl.removeMediaStreamTrack(*stream, *track);
8636 return JSValue::encode(jsUndefined());
8637}
8638
8639EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionRemoveMediaStreamTrack(ExecState* state)
8640{
8641 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionRemoveMediaStreamTrackBody>(*state, "removeMediaStreamTrack");
8642}
8643
8644#endif
8645
8646#if ENABLE(MEDIA_STREAM)
8647static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8648{
8649 UNUSED_PARAM(state);
8650 UNUSED_PARAM(throwScope);
8651 auto& impl = castedThis->wrapped();
8652 if (UNLIKELY(state->argumentCount() < 1))
8653 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8654 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "simulateMediaStreamTrackCaptureSourceFailure", "MediaStreamTrack"); });
8655 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8656 impl.simulateMediaStreamTrackCaptureSourceFailure(*track);
8657 return JSValue::encode(jsUndefined());
8658}
8659
8660EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailure(ExecState* state)
8661{
8662 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSimulateMediaStreamTrackCaptureSourceFailureBody>(*state, "simulateMediaStreamTrackCaptureSourceFailure");
8663}
8664
8665#endif
8666
8667#if ENABLE(MEDIA_STREAM)
8668static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8669{
8670 UNUSED_PARAM(state);
8671 UNUSED_PARAM(throwScope);
8672 auto& impl = castedThis->wrapped();
8673 if (UNLIKELY(state->argumentCount() < 2))
8674 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8675 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamTrackIdentifier", "MediaStreamTrack"); });
8676 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8677 auto identifier = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
8678 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8679 impl.setMediaStreamTrackIdentifier(*track, WTFMove(identifier));
8680 return JSValue::encode(jsUndefined());
8681}
8682
8683EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifier(ExecState* state)
8684{
8685 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamTrackIdentifierBody>(*state, "setMediaStreamTrackIdentifier");
8686}
8687
8688#endif
8689
8690#if ENABLE(MEDIA_STREAM)
8691static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetMediaStreamSourceInterruptedBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8692{
8693 UNUSED_PARAM(state);
8694 UNUSED_PARAM(throwScope);
8695 auto& impl = castedThis->wrapped();
8696 if (UNLIKELY(state->argumentCount() < 2))
8697 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8698 auto track = convert<IDLInterface<MediaStreamTrack>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "track", "Internals", "setMediaStreamSourceInterrupted", "MediaStreamTrack"); });
8699 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8700 auto interrupted = convert<IDLBoolean>(*state, state->uncheckedArgument(1));
8701 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8702 impl.setMediaStreamSourceInterrupted(*track, WTFMove(interrupted));
8703 return JSValue::encode(jsUndefined());
8704}
8705
8706EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetMediaStreamSourceInterrupted(ExecState* state)
8707{
8708 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetMediaStreamSourceInterruptedBody>(*state, "setMediaStreamSourceInterrupted");
8709}
8710
8711#endif
8712
8713#if ENABLE(MEDIA_STREAM)
8714static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraintBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8715{
8716 UNUSED_PARAM(state);
8717 UNUSED_PARAM(throwScope);
8718 auto& impl = castedThis->wrapped();
8719 if (UNLIKELY(state->argumentCount() < 1))
8720 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8721 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
8722 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8723 impl.setDisableGetDisplayMediaUserGestureConstraint(WTFMove(value));
8724 return JSValue::encode(jsUndefined());
8725}
8726
8727EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraint(ExecState* state)
8728{
8729 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetDisableGetDisplayMediaUserGestureConstraintBody>(*state, "setDisableGetDisplayMediaUserGestureConstraint");
8730}
8731
8732#endif
8733
8734static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionDocumentIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8735{
8736 UNUSED_PARAM(state);
8737 UNUSED_PARAM(throwScope);
8738 auto& impl = castedThis->wrapped();
8739 if (UNLIKELY(state->argumentCount() < 1))
8740 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8741 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "documentIdentifier", "Document"); });
8742 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8743 return JSValue::encode(toJS<IDLUnsignedLongLong>(impl.documentIdentifier(*document)));
8744}
8745
8746EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionDocumentIdentifier(ExecState* state)
8747{
8748 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionDocumentIdentifierBody>(*state, "documentIdentifier");
8749}
8750
8751static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsDocumentAliveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8752{
8753 UNUSED_PARAM(state);
8754 UNUSED_PARAM(throwScope);
8755 auto& impl = castedThis->wrapped();
8756 if (UNLIKELY(state->argumentCount() < 1))
8757 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8758 auto documentIdentifier = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(0));
8759 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8760 return JSValue::encode(toJS<IDLBoolean>(impl.isDocumentAlive(WTFMove(documentIdentifier))));
8761}
8762
8763EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsDocumentAlive(ExecState* state)
8764{
8765 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsDocumentAliveBody>(*state, "isDocumentAlive");
8766}
8767
8768static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAliveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8769{
8770 UNUSED_PARAM(state);
8771 UNUSED_PARAM(throwScope);
8772 auto& impl = castedThis->wrapped();
8773 return JSValue::encode(toJS<IDLBoolean>(impl.isAnyWorkletGlobalScopeAlive()));
8774}
8775
8776EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAlive(ExecState* state)
8777{
8778 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsAnyWorkletGlobalScopeAliveBody>(*state, "isAnyWorkletGlobalScopeAlive");
8779}
8780
8781static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionServiceWorkerClientIdentifierBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8782{
8783 UNUSED_PARAM(state);
8784 UNUSED_PARAM(throwScope);
8785 auto& impl = castedThis->wrapped();
8786 if (UNLIKELY(state->argumentCount() < 1))
8787 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8788 auto document = convert<IDLInterface<Document>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "document", "Internals", "serviceWorkerClientIdentifier", "Document"); });
8789 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8790 return JSValue::encode(toJS<IDLDOMString>(*state, impl.serviceWorkerClientIdentifier(*document)));
8791}
8792
8793EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionServiceWorkerClientIdentifier(ExecState* state)
8794{
8795 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionServiceWorkerClientIdentifierBody>(*state, "serviceWorkerClientIdentifier");
8796}
8797
8798static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8799{
8800 UNUSED_PARAM(state);
8801 UNUSED_PARAM(throwScope);
8802 auto& impl = castedThis->wrapped();
8803 impl.clearCacheStorageMemoryRepresentation(WTFMove(promise));
8804 return JSValue::encode(jsUndefined());
8805}
8806
8807EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentation(ExecState* state)
8808{
8809 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionClearCacheStorageMemoryRepresentationBody, PromiseExecutionScope::WindowOnly>(*state, "clearCacheStorageMemoryRepresentation");
8810}
8811
8812static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCacheStorageEngineRepresentationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8813{
8814 UNUSED_PARAM(state);
8815 UNUSED_PARAM(throwScope);
8816 auto& impl = castedThis->wrapped();
8817 impl.cacheStorageEngineRepresentation(WTFMove(promise));
8818 return JSValue::encode(jsUndefined());
8819}
8820
8821EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCacheStorageEngineRepresentation(ExecState* state)
8822{
8823 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionCacheStorageEngineRepresentationBody, PromiseExecutionScope::WindowOnly>(*state, "cacheStorageEngineRepresentation");
8824}
8825
8826static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetResponseSizeWithPaddingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8827{
8828 UNUSED_PARAM(state);
8829 UNUSED_PARAM(throwScope);
8830 auto& impl = castedThis->wrapped();
8831 if (UNLIKELY(state->argumentCount() < 2))
8832 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8833 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "setResponseSizeWithPadding", "FetchResponse"); });
8834 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8835 auto size = convert<IDLUnsignedLongLong>(*state, state->uncheckedArgument(1));
8836 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8837 impl.setResponseSizeWithPadding(*response, WTFMove(size));
8838 return JSValue::encode(jsUndefined());
8839}
8840
8841EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetResponseSizeWithPadding(ExecState* state)
8842{
8843 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetResponseSizeWithPaddingBody>(*state, "setResponseSizeWithPadding");
8844}
8845
8846static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionResponseSizeWithPaddingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8847{
8848 UNUSED_PARAM(state);
8849 UNUSED_PARAM(throwScope);
8850 auto& impl = castedThis->wrapped();
8851 if (UNLIKELY(state->argumentCount() < 1))
8852 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8853 auto response = convert<IDLInterface<FetchResponse>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "response", "Internals", "responseSizeWithPadding", "FetchResponse"); });
8854 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8855 return JSValue::encode(toJS<IDLUnsignedLongLong>(impl.responseSizeWithPadding(*response)));
8856}
8857
8858EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionResponseSizeWithPadding(ExecState* state)
8859{
8860 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionResponseSizeWithPaddingBody>(*state, "responseSizeWithPadding");
8861}
8862
8863static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsageBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8864{
8865 UNUSED_PARAM(state);
8866 UNUSED_PARAM(throwScope);
8867 auto& impl = castedThis->wrapped();
8868 impl.updateQuotaBasedOnSpaceUsage();
8869 return JSValue::encode(jsUndefined());
8870}
8871
8872EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsage(ExecState* state)
8873{
8874 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUpdateQuotaBasedOnSpaceUsageBody>(*state, "updateQuotaBasedOnSpaceUsage");
8875}
8876
8877static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetConsoleMessageListenerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8878{
8879 UNUSED_PARAM(state);
8880 UNUSED_PARAM(throwScope);
8881 auto& impl = castedThis->wrapped();
8882 if (UNLIKELY(state->argumentCount() < 1))
8883 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8884 auto callback = convert<IDLCallbackFunction<JSStringCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "setConsoleMessageListener"); });
8885 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8886 impl.setConsoleMessageListener(callback.releaseNonNull());
8887 return JSValue::encode(jsUndefined());
8888}
8889
8890EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetConsoleMessageListener(ExecState* state)
8891{
8892 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetConsoleMessageListenerBody>(*state, "setConsoleMessageListener");
8893}
8894
8895static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAudioSessionCategoryBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8896{
8897 UNUSED_PARAM(state);
8898 UNUSED_PARAM(throwScope);
8899 auto& impl = castedThis->wrapped();
8900 return JSValue::encode(toJS<IDLDOMString>(*state, impl.audioSessionCategory()));
8901}
8902
8903EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionCategory(ExecState* state)
8904{
8905 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAudioSessionCategoryBody>(*state, "audioSessionCategory");
8906}
8907
8908static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPreferredAudioBufferSizeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8909{
8910 UNUSED_PARAM(state);
8911 UNUSED_PARAM(throwScope);
8912 auto& impl = castedThis->wrapped();
8913 return JSValue::encode(toJS<IDLDouble>(impl.preferredAudioBufferSize()));
8914}
8915
8916EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPreferredAudioBufferSize(ExecState* state)
8917{
8918 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPreferredAudioBufferSizeBody>(*state, "preferredAudioBufferSize");
8919}
8920
8921static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionAudioSessionActiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8922{
8923 UNUSED_PARAM(state);
8924 UNUSED_PARAM(throwScope);
8925 auto& impl = castedThis->wrapped();
8926 return JSValue::encode(toJS<IDLBoolean>(impl.audioSessionActive()));
8927}
8928
8929EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionAudioSessionActive(ExecState* state)
8930{
8931 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionAudioSessionActiveBody>(*state, "audioSessionActive");
8932}
8933
8934#if ENABLE(SERVICE_WORKER)
8935static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasServiceWorkerRegistrationBody(JSC::ExecState* state, typename IDLOperationReturningPromise<JSInternals>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
8936{
8937 UNUSED_PARAM(state);
8938 UNUSED_PARAM(throwScope);
8939 auto& impl = castedThis->wrapped();
8940 if (UNLIKELY(state->argumentCount() < 1))
8941 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8942 auto scopeURL = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
8943 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8944 impl.hasServiceWorkerRegistration(WTFMove(scopeURL), WTFMove(promise));
8945 return JSValue::encode(jsUndefined());
8946}
8947
8948EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerRegistration(ExecState* state)
8949{
8950 return IDLOperationReturningPromise<JSInternals>::call<jsInternalsPrototypeFunctionHasServiceWorkerRegistrationBody, PromiseExecutionScope::WindowOnly>(*state, "hasServiceWorkerRegistration");
8951}
8952
8953#endif
8954
8955#if ENABLE(SERVICE_WORKER)
8956static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTerminateServiceWorkerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8957{
8958 UNUSED_PARAM(state);
8959 UNUSED_PARAM(throwScope);
8960 auto& impl = castedThis->wrapped();
8961 if (UNLIKELY(state->argumentCount() < 1))
8962 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8963 auto worker = convert<IDLInterface<ServiceWorker>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "worker", "Internals", "terminateServiceWorker", "ServiceWorker"); });
8964 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
8965 impl.terminateServiceWorker(*worker);
8966 return JSValue::encode(jsUndefined());
8967}
8968
8969EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTerminateServiceWorker(ExecState* state)
8970{
8971 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTerminateServiceWorkerBody>(*state, "terminateServiceWorker");
8972}
8973
8974#endif
8975
8976#if ENABLE(SERVICE_WORKER)
8977static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionHasServiceWorkerConnectionBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8978{
8979 UNUSED_PARAM(state);
8980 UNUSED_PARAM(throwScope);
8981 auto& impl = castedThis->wrapped();
8982 return JSValue::encode(toJS<IDLBoolean>(impl.hasServiceWorkerConnection()));
8983}
8984
8985EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionHasServiceWorkerConnection(ExecState* state)
8986{
8987 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionHasServiceWorkerConnectionBody>(*state, "hasServiceWorkerConnection");
8988}
8989
8990#endif
8991
8992static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSystemPreviewLinkBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
8993{
8994 UNUSED_PARAM(state);
8995 UNUSED_PARAM(throwScope);
8996 auto& impl = castedThis->wrapped();
8997 if (UNLIKELY(state->argumentCount() < 1))
8998 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
8999 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSystemPreviewLink", "Element"); });
9000 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9001 return JSValue::encode(toJS<IDLBoolean>(impl.isSystemPreviewLink(*element)));
9002}
9003
9004EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewLink(ExecState* state)
9005{
9006 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSystemPreviewLinkBody>(*state, "isSystemPreviewLink");
9007}
9008
9009static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionIsSystemPreviewImageBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9010{
9011 UNUSED_PARAM(state);
9012 UNUSED_PARAM(throwScope);
9013 auto& impl = castedThis->wrapped();
9014 if (UNLIKELY(state->argumentCount() < 1))
9015 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9016 auto element = convert<IDLInterface<Element>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "isSystemPreviewImage", "Element"); });
9017 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9018 return JSValue::encode(toJS<IDLBoolean>(impl.isSystemPreviewImage(*element)));
9019}
9020
9021EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionIsSystemPreviewImage(ExecState* state)
9022{
9023 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionIsSystemPreviewImageBody>(*state, "isSystemPreviewImage");
9024}
9025
9026static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionUsingAppleInternalSDKBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9027{
9028 UNUSED_PARAM(state);
9029 UNUSED_PARAM(throwScope);
9030 auto& impl = castedThis->wrapped();
9031 return JSValue::encode(toJS<IDLBoolean>(impl.usingAppleInternalSDK()));
9032}
9033
9034EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionUsingAppleInternalSDK(ExecState* state)
9035{
9036 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionUsingAppleInternalSDKBody>(*state, "usingAppleInternalSDK");
9037}
9038
9039static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPostTaskBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9040{
9041 UNUSED_PARAM(state);
9042 UNUSED_PARAM(throwScope);
9043 auto& impl = castedThis->wrapped();
9044 if (UNLIKELY(state->argumentCount() < 1))
9045 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9046 auto callback = convert<IDLCallbackFunction<JSVoidCallback>>(*state, state->uncheckedArgument(0), *castedThis->globalObject(), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(state, scope, 0, "callback", "Internals", "postTask"); });
9047 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9048 impl.postTask(callback.releaseNonNull());
9049 return JSValue::encode(jsUndefined());
9050}
9051
9052EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPostTask(ExecState* state)
9053{
9054 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPostTaskBody>(*state, "postTask");
9055}
9056
9057static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMarkContextAsInsecureBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9058{
9059 UNUSED_PARAM(state);
9060 UNUSED_PARAM(throwScope);
9061 auto& impl = castedThis->wrapped();
9062 impl.markContextAsInsecure();
9063 return JSValue::encode(jsUndefined());
9064}
9065
9066EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMarkContextAsInsecure(ExecState* state)
9067{
9068 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMarkContextAsInsecureBody>(*state, "markContextAsInsecure");
9069}
9070
9071#if ENABLE(VIDEO)
9072static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManagerBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9073{
9074 UNUSED_PARAM(state);
9075 UNUSED_PARAM(throwScope);
9076 auto& impl = castedThis->wrapped();
9077 if (UNLIKELY(state->argumentCount() < 1))
9078 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9079 auto purpose = convert<IDLEnumeration<Internals::PlaybackControlsPurpose>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentMustBeEnumError(state, scope, 0, "purpose", "Internals", "bestMediaElementForShowingPlaybackControlsManager", expectedEnumerationValues<Internals::PlaybackControlsPurpose>()); });
9080 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9081 return JSValue::encode(toJS<IDLInterface<HTMLMediaElement>>(*state, *castedThis->globalObject(), impl.bestMediaElementForShowingPlaybackControlsManager(WTFMove(purpose))));
9082}
9083
9084EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManager(ExecState* state)
9085{
9086 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionBestMediaElementForShowingPlaybackControlsManagerBody>(*state, "bestMediaElementForShowingPlaybackControlsManager");
9087}
9088
9089#endif
9090
9091#if ENABLE(VIDEO)
9092static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionMediaSessionStateBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9093{
9094 UNUSED_PARAM(state);
9095 UNUSED_PARAM(throwScope);
9096 auto& impl = castedThis->wrapped();
9097 if (UNLIKELY(state->argumentCount() < 1))
9098 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9099 auto element = convert<IDLInterface<HTMLMediaElement>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "element", "Internals", "mediaSessionState", "HTMLMediaElement"); });
9100 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9101 return JSValue::encode(toJS<IDLEnumeration<Internals::MediaSessionState>>(*state, impl.mediaSessionState(*element)));
9102}
9103
9104EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionMediaSessionState(ExecState* state)
9105{
9106 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionMediaSessionStateBody>(*state, "mediaSessionState");
9107}
9108
9109#endif
9110
9111static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionOngoingLoadsDescriptionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9112{
9113 UNUSED_PARAM(state);
9114 UNUSED_PARAM(throwScope);
9115 auto& impl = castedThis->wrapped();
9116 return JSValue::encode(toJS<IDLDOMString>(*state, impl.ongoingLoadsDescriptions()));
9117}
9118
9119EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionOngoingLoadsDescriptions(ExecState* state)
9120{
9121 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionOngoingLoadsDescriptionsBody>(*state, "ongoingLoadsDescriptions");
9122}
9123
9124static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabledBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9125{
9126 UNUSED_PARAM(state);
9127 UNUSED_PARAM(throwScope);
9128 auto& impl = castedThis->wrapped();
9129 if (UNLIKELY(state->argumentCount() < 1))
9130 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9131 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9132 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9133 impl.setCaptureExtraNetworkLoadMetricsEnabled(WTFMove(value));
9134 return JSValue::encode(jsUndefined());
9135}
9136
9137EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabled(ExecState* state)
9138{
9139 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetCaptureExtraNetworkLoadMetricsEnabledBody>(*state, "setCaptureExtraNetworkLoadMetricsEnabled");
9140}
9141
9142static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionReloadWithoutContentExtensionsBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9143{
9144 UNUSED_PARAM(state);
9145 UNUSED_PARAM(throwScope);
9146 auto& impl = castedThis->wrapped();
9147 impl.reloadWithoutContentExtensions();
9148 return JSValue::encode(jsUndefined());
9149}
9150
9151EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionReloadWithoutContentExtensions(ExecState* state)
9152{
9153 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionReloadWithoutContentExtensionsBody>(*state, "reloadWithoutContentExtensions");
9154}
9155
9156static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetUseSystemAppearanceBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9157{
9158 UNUSED_PARAM(state);
9159 UNUSED_PARAM(throwScope);
9160 auto& impl = castedThis->wrapped();
9161 if (UNLIKELY(state->argumentCount() < 1))
9162 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9163 auto value = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9164 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9165 impl.setUseSystemAppearance(WTFMove(value));
9166 return JSValue::encode(jsUndefined());
9167}
9168
9169EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetUseSystemAppearance(ExecState* state)
9170{
9171 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetUseSystemAppearanceBody>(*state, "setUseSystemAppearance");
9172}
9173
9174static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPluginCountBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9175{
9176 UNUSED_PARAM(state);
9177 UNUSED_PARAM(throwScope);
9178 auto& impl = castedThis->wrapped();
9179 return JSValue::encode(toJS<IDLUnsignedLong>(impl.pluginCount()));
9180}
9181
9182EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPluginCount(ExecState* state)
9183{
9184 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPluginCountBody>(*state, "pluginCount");
9185}
9186
9187static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionNotifyResourceLoadObserverBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9188{
9189 UNUSED_PARAM(state);
9190 UNUSED_PARAM(throwScope);
9191 auto& impl = castedThis->wrapped();
9192 impl.notifyResourceLoadObserver();
9193 return JSValue::encode(jsUndefined());
9194}
9195
9196EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionNotifyResourceLoadObserver(ExecState* state)
9197{
9198 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionNotifyResourceLoadObserverBody>(*state, "notifyResourceLoadObserver");
9199}
9200
9201static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionPrimaryScreenDisplayIDBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9202{
9203 UNUSED_PARAM(state);
9204 UNUSED_PARAM(throwScope);
9205 auto& impl = castedThis->wrapped();
9206 return JSValue::encode(toJS<IDLUnsignedLong>(impl.primaryScreenDisplayID()));
9207}
9208
9209EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionPrimaryScreenDisplayID(ExecState* state)
9210{
9211 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionPrimaryScreenDisplayIDBody>(*state, "primaryScreenDisplayID");
9212}
9213
9214static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionCapsLockIsOnBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9215{
9216 UNUSED_PARAM(state);
9217 UNUSED_PARAM(throwScope);
9218 auto& impl = castedThis->wrapped();
9219 return JSValue::encode(toJS<IDLBoolean>(impl.capsLockIsOn()));
9220}
9221
9222EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionCapsLockIsOn(ExecState* state)
9223{
9224 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionCapsLockIsOnBody>(*state, "capsLockIsOn");
9225}
9226
9227static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSupportsVCPEncoderBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9228{
9229 UNUSED_PARAM(state);
9230 UNUSED_PARAM(throwScope);
9231 auto& impl = castedThis->wrapped();
9232 return JSValue::encode(toJS<IDLBoolean>(impl.supportsVCPEncoder()));
9233}
9234
9235EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSupportsVCPEncoder(ExecState* state)
9236{
9237 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSupportsVCPEncoderBody>(*state, "supportsVCPEncoder");
9238}
9239
9240static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionParseHEVCCodecParametersBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9241{
9242 UNUSED_PARAM(state);
9243 UNUSED_PARAM(throwScope);
9244 auto& impl = castedThis->wrapped();
9245 if (UNLIKELY(state->argumentCount() < 1))
9246 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9247 auto codecParameters = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
9248 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9249 return JSValue::encode(toJS<IDLNullable<IDLDictionary<Internals::HEVCParameterSet>>>(*state, *castedThis->globalObject(), impl.parseHEVCCodecParameters(WTFMove(codecParameters))));
9250}
9251
9252EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionParseHEVCCodecParameters(ExecState* state)
9253{
9254 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionParseHEVCCodecParametersBody>(*state, "parseHEVCCodecParameters");
9255}
9256
9257static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionGetCookiesBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9258{
9259 UNUSED_PARAM(state);
9260 UNUSED_PARAM(throwScope);
9261 auto& impl = castedThis->wrapped();
9262 return JSValue::encode(toJS<IDLSequence<IDLDictionary<Internals::CookieData>>>(*state, *castedThis->globalObject(), impl.getCookies()));
9263}
9264
9265EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionGetCookies(ExecState* state)
9266{
9267 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionGetCookiesBody>(*state, "getCookies");
9268}
9269
9270static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchiveBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9271{
9272 UNUSED_PARAM(state);
9273 UNUSED_PARAM(throwScope);
9274 auto& impl = castedThis->wrapped();
9275 if (UNLIKELY(state->argumentCount() < 1))
9276 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9277 auto alwaysAllowLocalWebarchive = convert<IDLBoolean>(*state, state->uncheckedArgument(0));
9278 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9279 impl.setAlwaysAllowLocalWebarchive(WTFMove(alwaysAllowLocalWebarchive));
9280 return JSValue::encode(jsUndefined());
9281}
9282
9283EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchive(ExecState* state)
9284{
9285 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetAlwaysAllowLocalWebarchiveBody>(*state, "setAlwaysAllowLocalWebarchive");
9286}
9287
9288static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionProcessWillSuspendBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9289{
9290 UNUSED_PARAM(state);
9291 UNUSED_PARAM(throwScope);
9292 auto& impl = castedThis->wrapped();
9293 impl.processWillSuspend();
9294 return JSValue::encode(jsUndefined());
9295}
9296
9297EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessWillSuspend(ExecState* state)
9298{
9299 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionProcessWillSuspendBody>(*state, "processWillSuspend");
9300}
9301
9302static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionProcessDidResumeBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9303{
9304 UNUSED_PARAM(state);
9305 UNUSED_PARAM(throwScope);
9306 auto& impl = castedThis->wrapped();
9307 impl.processDidResume();
9308 return JSValue::encode(jsUndefined());
9309}
9310
9311EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionProcessDidResume(ExecState* state)
9312{
9313 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionProcessDidResumeBody>(*state, "processDidResume");
9314}
9315
9316static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionTestDictionaryLoggingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9317{
9318 UNUSED_PARAM(state);
9319 UNUSED_PARAM(throwScope);
9320 auto& impl = castedThis->wrapped();
9321 impl.testDictionaryLogging();
9322 return JSValue::encode(jsUndefined());
9323}
9324
9325EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionTestDictionaryLogging(ExecState* state)
9326{
9327 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionTestDictionaryLoggingBody>(*state, "testDictionaryLogging");
9328}
9329
9330static inline JSC::EncodedJSValue jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwardingBody(JSC::ExecState* state, typename IDLOperation<JSInternals>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
9331{
9332 UNUSED_PARAM(state);
9333 UNUSED_PARAM(throwScope);
9334 auto& impl = castedThis->wrapped();
9335 if (UNLIKELY(state->argumentCount() < 2))
9336 return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
9337 auto xhr = convert<IDLInterface<XMLHttpRequest>>(*state, state->uncheckedArgument(0), [](JSC::ExecState& state, JSC::ThrowScope& scope) { throwArgumentTypeError(state, scope, 0, "xhr", "Internals", "setXHRMaximumIntervalForUserGestureForwarding", "XMLHttpRequest"); });
9338 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9339 auto interval = convert<IDLDouble>(*state, state->uncheckedArgument(1));
9340 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
9341 impl.setXHRMaximumIntervalForUserGestureForwarding(*xhr, WTFMove(interval));
9342 return JSValue::encode(jsUndefined());
9343}
9344
9345EncodedJSValue JSC_HOST_CALL jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwarding(ExecState* state)
9346{
9347 return IDLOperation<JSInternals>::call<jsInternalsPrototypeFunctionSetXHRMaximumIntervalForUserGestureForwardingBody>(*state, "setXHRMaximumIntervalForUserGestureForwarding");
9348}
9349
9350void JSInternals::heapSnapshot(JSCell* cell, HeapSnapshotBuilder& builder)
9351{
9352 auto* thisObject = jsCast<JSInternals*>(cell);
9353 builder.setWrappedObjectForCell(cell, &thisObject->wrapped());
9354 if (thisObject->scriptExecutionContext())
9355 builder.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
9356 Base::heapSnapshot(cell, builder);
9357}
9358
9359bool JSInternalsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor, const char** reason)
9360{
9361 UNUSED_PARAM(handle);
9362 UNUSED_PARAM(visitor);
9363 UNUSED_PARAM(reason);
9364 return false;
9365}
9366
9367void JSInternalsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
9368{
9369 auto* jsInternals = static_cast<JSInternals*>(handle.slot()->asCell());
9370 auto& world = *static_cast<DOMWrapperWorld*>(context);
9371 uncacheWrapper(world, &jsInternals->wrapped(), jsInternals);
9372}
9373
9374#if ENABLE(BINDING_INTEGRITY)
9375#if PLATFORM(WIN)
9376#pragma warning(disable: 4483)
9377extern "C" { extern void (*const __identifier("??_7Internals@WebCore@@6B@")[])(); }
9378#else
9379extern "C" { extern void* _ZTVN7WebCore9InternalsE[]; }
9380#endif
9381#endif
9382
9383JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<Internals>&& impl)
9384{
9385
9386#if ENABLE(BINDING_INTEGRITY)
9387 void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
9388#if PLATFORM(WIN)
9389 void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(__identifier("??_7Internals@WebCore@@6B@"));
9390#else
9391 void* expectedVTablePointer = WTF_PREPARE_VTBL_POINTER_FOR_INSPECTION(&_ZTVN7WebCore9InternalsE[2]);
9392#endif
9393
9394 // If this fails Internals does not have a vtable, so you need to add the
9395 // ImplementationLacksVTable attribute to the interface definition
9396 static_assert(std::is_polymorphic<Internals>::value, "Internals is not polymorphic");
9397
9398 // If you hit this assertion you either have a use after free bug, or
9399 // Internals has subclasses. If Internals has subclasses that get passed
9400 // to toJS() we currently require Internals you to opt out of binding hardening
9401 // by adding the SkipVTableValidation attribute to the interface IDL definition
9402 RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
9403#endif
9404 return createWrapper<Internals>(globalObject, WTFMove(impl));
9405}
9406
9407JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, Internals& impl)
9408{
9409 return wrap(state, globalObject, impl);
9410}
9411
9412Internals* JSInternals::toWrapped(JSC::VM& vm, JSC::JSValue value)
9413{
9414 if (auto* wrapper = jsDynamicCast<JSInternals*>(vm, value))
9415 return &wrapper->wrapped();
9416 return nullptr;
9417}
9418
9419}
9420