#include <LibGC/DeferGC.h>
#include <LibJS/Runtime/Object.h>
#include <LibWeb/Bindings/InterfaceObject.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/PrincipalHostDefined.h>
#include <LibWeb/Export.h>
#include <LibWeb/HTML/Window.h>
#include <LibWeb/HTML/DedicatedWorkerGlobalScope.h>
#include <LibWeb/HTML/SharedWorkerGlobalScope.h>
#include <LibWeb/Bindings/Animation.h>
#include <LibWeb/Bindings/AnimationEffect.h>
#include <LibWeb/Bindings/AnimationPlaybackEvent.h>
#include <LibWeb/Bindings/AnimationTimeline.h>
#include <LibWeb/Bindings/DocumentTimeline.h>
#include <LibWeb/Bindings/KeyframeEffect.h>
#include <LibWeb/Bindings/ScrollTimeline.h>
#include <LibWeb/Bindings/Clipboard.h>
#include <LibWeb/Bindings/ClipboardEvent.h>
#include <LibWeb/Bindings/ClipboardItem.h>
#include <LibWeb/Bindings/CompressionStream.h>
#include <LibWeb/Bindings/DecompressionStream.h>
#include <LibWeb/Bindings/SecurityPolicyViolationEvent.h>
#include <LibWeb/Bindings/CookieChangeEvent.h>
#include <LibWeb/Bindings/CookieStore.h>
#include <LibWeb/Bindings/Credential.h>
#include <LibWeb/Bindings/CredentialsContainer.h>
#include <LibWeb/Bindings/FederatedCredential.h>
#include <LibWeb/Bindings/PasswordCredential.h>
#include <LibWeb/Bindings/Crypto.h>
#include <LibWeb/Bindings/CryptoKey.h>
#include <LibWeb/Bindings/SubtleCrypto.h>
#include <LibWeb/Bindings/AnimationEvent.h>
#include <LibWeb/Bindings/CSS.h>
#include <LibWeb/Bindings/CSSAnimation.h>
#include <LibWeb/Bindings/CSSConditionRule.h>
#include <LibWeb/Bindings/CSSContainerRule.h>
#include <LibWeb/Bindings/CSSCounterStyleRule.h>
#include <LibWeb/Bindings/CSSFontFaceDescriptors.h>
#include <LibWeb/Bindings/CSSFontFaceRule.h>
#include <LibWeb/Bindings/CSSFontFeatureValuesMap.h>
#include <LibWeb/Bindings/CSSFontFeatureValuesRule.h>
#include <LibWeb/Bindings/CSSFunctionDeclarations.h>
#include <LibWeb/Bindings/CSSFunctionDescriptors.h>
#include <LibWeb/Bindings/CSSFunctionRule.h>
#include <LibWeb/Bindings/CSSGroupingRule.h>
#include <LibWeb/Bindings/CSSImageValue.h>
#include <LibWeb/Bindings/CSSImportRule.h>
#include <LibWeb/Bindings/CSSKeyframeRule.h>
#include <LibWeb/Bindings/CSSKeyframesRule.h>
#include <LibWeb/Bindings/CSSKeywordValue.h>
#include <LibWeb/Bindings/CSSLayerBlockRule.h>
#include <LibWeb/Bindings/CSSLayerStatementRule.h>
#include <LibWeb/Bindings/CSSMarginRule.h>
#include <LibWeb/Bindings/CSSMathClamp.h>
#include <LibWeb/Bindings/CSSMathInvert.h>
#include <LibWeb/Bindings/CSSMathMax.h>
#include <LibWeb/Bindings/CSSMathMin.h>
#include <LibWeb/Bindings/CSSMathNegate.h>
#include <LibWeb/Bindings/CSSMathProduct.h>
#include <LibWeb/Bindings/CSSMathSum.h>
#include <LibWeb/Bindings/CSSMathValue.h>
#include <LibWeb/Bindings/CSSMatrixComponent.h>
#include <LibWeb/Bindings/CSSMediaRule.h>
#include <LibWeb/Bindings/CSSNamespaceRule.h>
#include <LibWeb/Bindings/CSSNestedDeclarations.h>
#include <LibWeb/Bindings/CSSNumericArray.h>
#include <LibWeb/Bindings/CSSNumericValue.h>
#include <LibWeb/Bindings/CSSPageDescriptors.h>
#include <LibWeb/Bindings/CSSPageRule.h>
#include <LibWeb/Bindings/CSSPerspective.h>
#include <LibWeb/Bindings/CSSPropertyRule.h>
#include <LibWeb/Bindings/CSSRotate.h>
#include <LibWeb/Bindings/CSSRule.h>
#include <LibWeb/Bindings/CSSRuleList.h>
#include <LibWeb/Bindings/CSSScale.h>
#include <LibWeb/Bindings/CSSSkew.h>
#include <LibWeb/Bindings/CSSSkewX.h>
#include <LibWeb/Bindings/CSSSkewY.h>
#include <LibWeb/Bindings/CSSStyleDeclaration.h>
#include <LibWeb/Bindings/CSSStyleProperties.h>
#include <LibWeb/Bindings/CSSStyleRule.h>
#include <LibWeb/Bindings/CSSStyleSheet.h>
#include <LibWeb/Bindings/CSSStyleValue.h>
#include <LibWeb/Bindings/CSSSupportsRule.h>
#include <LibWeb/Bindings/CSSTransformComponent.h>
#include <LibWeb/Bindings/CSSTransformValue.h>
#include <LibWeb/Bindings/CSSTransition.h>
#include <LibWeb/Bindings/CSSTranslate.h>
#include <LibWeb/Bindings/CSSUnitValue.h>
#include <LibWeb/Bindings/CSSUnparsedValue.h>
#include <LibWeb/Bindings/CSSVariableReferenceValue.h>
#include <LibWeb/Bindings/FontFace.h>
#include <LibWeb/Bindings/FontFaceSet.h>
#include <LibWeb/Bindings/FontFaceSetLoadEvent.h>
#include <LibWeb/Bindings/MediaList.h>
#include <LibWeb/Bindings/MediaQueryList.h>
#include <LibWeb/Bindings/MediaQueryListEvent.h>
#include <LibWeb/Bindings/Screen.h>
#include <LibWeb/Bindings/ScreenOrientation.h>
#include <LibWeb/Bindings/StylePropertyMap.h>
#include <LibWeb/Bindings/StylePropertyMapReadOnly.h>
#include <LibWeb/Bindings/StyleSheet.h>
#include <LibWeb/Bindings/StyleSheetList.h>
#include <LibWeb/Bindings/TransitionEvent.h>
#include <LibWeb/Bindings/VisualViewport.h>
#include <LibWeb/Bindings/AbortController.h>
#include <LibWeb/Bindings/AbortSignal.h>
#include <LibWeb/Bindings/AbstractRange.h>
#include <LibWeb/Bindings/Attr.h>
#include <LibWeb/Bindings/CDATASection.h>
#include <LibWeb/Bindings/CharacterData.h>
#include <LibWeb/Bindings/Comment.h>
#include <LibWeb/Bindings/CustomEvent.h>
#include <LibWeb/Bindings/Document.h>
#include <LibWeb/Bindings/DocumentFragment.h>
#include <LibWeb/Bindings/DocumentType.h>
#include <LibWeb/Bindings/DOMImplementation.h>
#include <LibWeb/Bindings/DOMTokenList.h>
#include <LibWeb/Bindings/Element.h>
#include <LibWeb/Bindings/Event.h>
#include <LibWeb/Bindings/EventTarget.h>
#include <LibWeb/Bindings/HTMLCollection.h>
#include <LibWeb/Bindings/MutationObserver.h>
#include <LibWeb/Bindings/MutationRecord.h>
#include <LibWeb/Bindings/NamedNodeMap.h>
#include <LibWeb/Bindings/Node.h>
#include <LibWeb/Bindings/NodeFilter.h>
#include <LibWeb/Bindings/NodeIterator.h>
#include <LibWeb/Bindings/NodeList.h>
#include <LibWeb/Bindings/ProcessingInstruction.h>
#include <LibWeb/Bindings/Range.h>
#include <LibWeb/Bindings/ShadowRoot.h>
#include <LibWeb/Bindings/StaticRange.h>
#include <LibWeb/Bindings/Text.h>
#include <LibWeb/Bindings/TreeWalker.h>
#include <LibWeb/Bindings/XMLDocument.h>
#include <LibWeb/Bindings/DOMURL.h>
#include <LibWeb/Bindings/Origin.h>
#include <LibWeb/Bindings/URLSearchParams.h>
#include <LibWeb/Bindings/TextDecoder.h>
#include <LibWeb/Bindings/TextDecoderStream.h>
#include <LibWeb/Bindings/TextEncoder.h>
#include <LibWeb/Bindings/TextEncoderStream.h>
#include <LibWeb/Bindings/MediaKeySystemAccess.h>
#include <LibWeb/Bindings/FileSystemEntry.h>
#include <LibWeb/Bindings/PerformanceEventTiming.h>
#include <LibWeb/Bindings/Headers.h>
#include <LibWeb/Bindings/Request.h>
#include <LibWeb/Bindings/Response.h>
#include <LibWeb/Bindings/Blob.h>
#include <LibWeb/Bindings/File.h>
#include <LibWeb/Bindings/FileList.h>
#include <LibWeb/Bindings/FileReader.h>
#include <LibWeb/Bindings/FileReaderSync.h>
#include <LibWeb/Bindings/Gamepad.h>
#include <LibWeb/Bindings/GamepadButton.h>
#include <LibWeb/Bindings/GamepadEvent.h>
#include <LibWeb/Bindings/GamepadHapticActuator.h>
#include <LibWeb/Bindings/Geolocation.h>
#include <LibWeb/Bindings/GeolocationCoordinates.h>
#include <LibWeb/Bindings/GeolocationPosition.h>
#include <LibWeb/Bindings/GeolocationPositionError.h>
#include <LibWeb/Bindings/DOMMatrix.h>
#include <LibWeb/Bindings/DOMMatrixReadOnly.h>
#include <LibWeb/Bindings/DOMPoint.h>
#include <LibWeb/Bindings/DOMPointReadOnly.h>
#include <LibWeb/Bindings/DOMQuad.h>
#include <LibWeb/Bindings/DOMRect.h>
#include <LibWeb/Bindings/DOMRectList.h>
#include <LibWeb/Bindings/DOMRectReadOnly.h>
#include <LibWeb/Bindings/Performance.h>
#include <LibWeb/Bindings/AudioTrack.h>
#include <LibWeb/Bindings/AudioTrackList.h>
#include <LibWeb/Bindings/BarProp.h>
#include <LibWeb/Bindings/BeforeUnloadEvent.h>
#include <LibWeb/Bindings/BroadcastChannel.h>
#include <LibWeb/Bindings/CanvasGradient.h>
#include <LibWeb/Bindings/CanvasPattern.h>
#include <LibWeb/Bindings/CanvasRenderingContext2D.h>
#include <LibWeb/Bindings/CloseEvent.h>
#include <LibWeb/Bindings/CloseWatcher.h>
#include <LibWeb/Bindings/CommandEvent.h>
#include <LibWeb/Bindings/CustomElementRegistry.h>
#include <LibWeb/Bindings/CustomStateSet.h>
#include <LibWeb/Bindings/DataTransfer.h>
#include <LibWeb/Bindings/DataTransferItem.h>
#include <LibWeb/Bindings/DataTransferItemList.h>
#include <LibWeb/Bindings/DedicatedWorkerGlobalScope.h>
#include <LibWeb/Bindings/DOMParser.h>
#include <LibWeb/Bindings/DOMStringList.h>
#include <LibWeb/Bindings/DOMStringMap.h>
#include <LibWeb/Bindings/DragEvent.h>
#include <LibWeb/Bindings/ElementInternals.h>
#include <LibWeb/Bindings/ErrorEvent.h>
#include <LibWeb/Bindings/EventSource.h>
#include <LibWeb/Bindings/External.h>
#include <LibWeb/Bindings/FormDataEvent.h>
#include <LibWeb/Bindings/HashChangeEvent.h>
#include <LibWeb/Bindings/History.h>
#include <LibWeb/Bindings/HTMLAllCollection.h>
#include <LibWeb/Bindings/HTMLAnchorElement.h>
#include <LibWeb/Bindings/HTMLAreaElement.h>
#include <LibWeb/Bindings/HTMLAudioElement.h>
#include <LibWeb/Bindings/AudioConstructor.h>
#include <LibWeb/Bindings/HTMLBaseElement.h>
#include <LibWeb/Bindings/HTMLBodyElement.h>
#include <LibWeb/Bindings/HTMLBRElement.h>
#include <LibWeb/Bindings/HTMLButtonElement.h>
#include <LibWeb/Bindings/HTMLCanvasElement.h>
#include <LibWeb/Bindings/HTMLDataElement.h>
#include <LibWeb/Bindings/HTMLDataListElement.h>
#include <LibWeb/Bindings/HTMLDetailsElement.h>
#include <LibWeb/Bindings/HTMLDialogElement.h>
#include <LibWeb/Bindings/HTMLDirectoryElement.h>
#include <LibWeb/Bindings/HTMLDivElement.h>
#include <LibWeb/Bindings/HTMLDListElement.h>
#include <LibWeb/Bindings/HTMLDocument.h>
#include <LibWeb/Bindings/HTMLElement.h>
#include <LibWeb/Bindings/HTMLEmbedElement.h>
#include <LibWeb/Bindings/HTMLFieldSetElement.h>
#include <LibWeb/Bindings/HTMLFontElement.h>
#include <LibWeb/Bindings/HTMLFormControlsCollection.h>
#include <LibWeb/Bindings/HTMLFormElement.h>
#include <LibWeb/Bindings/HTMLFrameElement.h>
#include <LibWeb/Bindings/HTMLFrameSetElement.h>
#include <LibWeb/Bindings/HTMLHeadElement.h>
#include <LibWeb/Bindings/HTMLHeadingElement.h>
#include <LibWeb/Bindings/HTMLHRElement.h>
#include <LibWeb/Bindings/HTMLHtmlElement.h>
#include <LibWeb/Bindings/HTMLIFrameElement.h>
#include <LibWeb/Bindings/HTMLImageElement.h>
#include <LibWeb/Bindings/ImageConstructor.h>
#include <LibWeb/Bindings/HTMLInputElement.h>
#include <LibWeb/Bindings/HTMLLabelElement.h>
#include <LibWeb/Bindings/HTMLLegendElement.h>
#include <LibWeb/Bindings/HTMLLIElement.h>
#include <LibWeb/Bindings/HTMLLinkElement.h>
#include <LibWeb/Bindings/HTMLMapElement.h>
#include <LibWeb/Bindings/HTMLMarqueeElement.h>
#include <LibWeb/Bindings/HTMLMediaElement.h>
#include <LibWeb/Bindings/HTMLMenuElement.h>
#include <LibWeb/Bindings/HTMLMetaElement.h>
#include <LibWeb/Bindings/HTMLMeterElement.h>
#include <LibWeb/Bindings/HTMLModElement.h>
#include <LibWeb/Bindings/HTMLObjectElement.h>
#include <LibWeb/Bindings/HTMLOListElement.h>
#include <LibWeb/Bindings/HTMLOptGroupElement.h>
#include <LibWeb/Bindings/HTMLOptionElement.h>
#include <LibWeb/Bindings/OptionConstructor.h>
#include <LibWeb/Bindings/HTMLOptionsCollection.h>
#include <LibWeb/Bindings/HTMLOutputElement.h>
#include <LibWeb/Bindings/HTMLParagraphElement.h>
#include <LibWeb/Bindings/HTMLParamElement.h>
#include <LibWeb/Bindings/HTMLPictureElement.h>
#include <LibWeb/Bindings/HTMLPreElement.h>
#include <LibWeb/Bindings/HTMLProgressElement.h>
#include <LibWeb/Bindings/HTMLQuoteElement.h>
#include <LibWeb/Bindings/HTMLScriptElement.h>
#include <LibWeb/Bindings/HTMLSelectedContentElement.h>
#include <LibWeb/Bindings/HTMLSelectElement.h>
#include <LibWeb/Bindings/HTMLSlotElement.h>
#include <LibWeb/Bindings/HTMLSourceElement.h>
#include <LibWeb/Bindings/HTMLSpanElement.h>
#include <LibWeb/Bindings/HTMLStyleElement.h>
#include <LibWeb/Bindings/HTMLTableCaptionElement.h>
#include <LibWeb/Bindings/HTMLTableCellElement.h>
#include <LibWeb/Bindings/HTMLTableColElement.h>
#include <LibWeb/Bindings/HTMLTableElement.h>
#include <LibWeb/Bindings/HTMLTableRowElement.h>
#include <LibWeb/Bindings/HTMLTableSectionElement.h>
#include <LibWeb/Bindings/HTMLTemplateElement.h>
#include <LibWeb/Bindings/HTMLTextAreaElement.h>
#include <LibWeb/Bindings/HTMLTimeElement.h>
#include <LibWeb/Bindings/HTMLTitleElement.h>
#include <LibWeb/Bindings/HTMLTrackElement.h>
#include <LibWeb/Bindings/HTMLUListElement.h>
#include <LibWeb/Bindings/HTMLUnknownElement.h>
#include <LibWeb/Bindings/HTMLVideoElement.h>
#include <LibWeb/Bindings/ImageBitmap.h>
#include <LibWeb/Bindings/ImageData.h>
#include <LibWeb/Bindings/Location.h>
#include <LibWeb/Bindings/MediaError.h>
#include <LibWeb/Bindings/MessageChannel.h>
#include <LibWeb/Bindings/MessageEvent.h>
#include <LibWeb/Bindings/MessagePort.h>
#include <LibWeb/Bindings/MimeType.h>
#include <LibWeb/Bindings/MimeTypeArray.h>
#include <LibWeb/Bindings/NavigateEvent.h>
#include <LibWeb/Bindings/Navigation.h>
#include <LibWeb/Bindings/NavigationCurrentEntryChangeEvent.h>
#include <LibWeb/Bindings/NavigationDestination.h>
#include <LibWeb/Bindings/NavigationHistoryEntry.h>
#include <LibWeb/Bindings/NavigationTransition.h>
#include <LibWeb/Bindings/Navigator.h>
#include <LibWeb/Bindings/OffscreenCanvas.h>
#include <LibWeb/Bindings/OffscreenCanvasRenderingContext2D.h>
#include <LibWeb/Bindings/PageTransitionEvent.h>
#include <LibWeb/Bindings/Path2D.h>
#include <LibWeb/Bindings/Plugin.h>
#include <LibWeb/Bindings/PluginArray.h>
#include <LibWeb/Bindings/PopStateEvent.h>
#include <LibWeb/Bindings/PromiseRejectionEvent.h>
#include <LibWeb/Bindings/RadioNodeList.h>
#include <LibWeb/Bindings/SharedWorker.h>
#include <LibWeb/Bindings/SharedWorkerGlobalScope.h>
#include <LibWeb/Bindings/Storage.h>
#include <LibWeb/Bindings/StorageEvent.h>
#include <LibWeb/Bindings/SubmitEvent.h>
#include <LibWeb/Bindings/TextMetrics.h>
#include <LibWeb/Bindings/TextTrack.h>
#include <LibWeb/Bindings/TextTrackCue.h>
#include <LibWeb/Bindings/TextTrackCueList.h>
#include <LibWeb/Bindings/TextTrackList.h>
#include <LibWeb/Bindings/TimeRanges.h>
#include <LibWeb/Bindings/ToggleEvent.h>
#include <LibWeb/Bindings/TrackEvent.h>
#include <LibWeb/Bindings/UserActivation.h>
#include <LibWeb/Bindings/ValidityState.h>
#include <LibWeb/Bindings/VideoTrack.h>
#include <LibWeb/Bindings/VideoTrackList.h>
#include <LibWeb/Bindings/Window.h>
#include <LibWeb/Bindings/Worker.h>
#include <LibWeb/Bindings/WorkerGlobalScope.h>
#include <LibWeb/Bindings/WorkerLocation.h>
#include <LibWeb/Bindings/WorkerNavigator.h>
#include <LibWeb/Bindings/WorkletGlobalScope.h>
#include <LibWeb/Bindings/XMLSerializer.h>
#include <LibWeb/Bindings/IDBCursor.h>
#include <LibWeb/Bindings/IDBCursorWithValue.h>
#include <LibWeb/Bindings/IDBDatabase.h>
#include <LibWeb/Bindings/IDBFactory.h>
#include <LibWeb/Bindings/IDBIndex.h>
#include <LibWeb/Bindings/IDBKeyRange.h>
#include <LibWeb/Bindings/IDBObjectStore.h>
#include <LibWeb/Bindings/IDBOpenDBRequest.h>
#include <LibWeb/Bindings/IDBRecord.h>
#include <LibWeb/Bindings/IDBRequest.h>
#include <LibWeb/Bindings/IDBTransaction.h>
#include <LibWeb/Bindings/IDBVersionChangeEvent.h>
#include <LibWeb/Bindings/FakeXRDevice.h>
#include <LibWeb/Bindings/InternalAnimationTimeline.h>
#include <LibWeb/Bindings/InternalGamepad.h>
#include <LibWeb/Bindings/Internals.h>
#include <LibWeb/Bindings/WebUI.h>
#include <LibWeb/Bindings/XRTest.h>
#include <LibWeb/Bindings/IntersectionObserver.h>
#include <LibWeb/Bindings/IntersectionObserverEntry.h>
#include <LibWeb/Bindings/MathMLElement.h>
#include <LibWeb/Bindings/MediaCapabilities.h>
#include <LibWeb/Bindings/MediaDeviceInfo.h>
#include <LibWeb/Bindings/MediaDevices.h>
#include <LibWeb/Bindings/MediaStream.h>
#include <LibWeb/Bindings/MediaStreamTrack.h>
#include <LibWeb/Bindings/MediaStreamTrackEvent.h>
#include <LibWeb/Bindings/BufferedChangeEvent.h>
#include <LibWeb/Bindings/ManagedMediaSource.h>
#include <LibWeb/Bindings/ManagedSourceBuffer.h>
#include <LibWeb/Bindings/MediaSource.h>
#include <LibWeb/Bindings/MediaSourceHandle.h>
#include <LibWeb/Bindings/SourceBuffer.h>
#include <LibWeb/Bindings/SourceBufferList.h>
#include <LibWeb/Bindings/PerformanceNavigation.h>
#include <LibWeb/Bindings/PerformanceTiming.h>
#include <LibWeb/Bindings/Notification.h>
#include <LibWeb/Bindings/PerformanceEntry.h>
#include <LibWeb/Bindings/PerformanceObserver.h>
#include <LibWeb/Bindings/PerformanceObserverEntryList.h>
#include <LibWeb/Bindings/Permissions.h>
#include <LibWeb/Bindings/PermissionStatus.h>
#include <LibWeb/Bindings/IdleDeadline.h>
#include <LibWeb/Bindings/ResizeObserver.h>
#include <LibWeb/Bindings/ResizeObserverEntry.h>
#include <LibWeb/Bindings/ResizeObserverSize.h>
#include <LibWeb/Bindings/PerformanceResourceTiming.h>
#include <LibWeb/Bindings/Selection.h>
#include <LibWeb/Bindings/Serial.h>
#include <LibWeb/Bindings/SerialPort.h>
#include <LibWeb/Bindings/Cache.h>
#include <LibWeb/Bindings/CacheStorage.h>
#include <LibWeb/Bindings/ServiceWorker.h>
#include <LibWeb/Bindings/ServiceWorkerContainer.h>
#include <LibWeb/Bindings/ServiceWorkerGlobalScope.h>
#include <LibWeb/Bindings/ServiceWorkerRegistration.h>
#include <LibWeb/Bindings/SpeechGrammar.h>
#include <LibWeb/Bindings/SpeechGrammarList.h>
#include <LibWeb/Bindings/SpeechRecognition.h>
#include <LibWeb/Bindings/SpeechRecognitionAlternative.h>
#include <LibWeb/Bindings/SpeechRecognitionEvent.h>
#include <LibWeb/Bindings/SpeechRecognitionPhrase.h>
#include <LibWeb/Bindings/SpeechRecognitionResult.h>
#include <LibWeb/Bindings/SpeechRecognitionResultList.h>
#include <LibWeb/Bindings/SpeechSynthesis.h>
#include <LibWeb/Bindings/SpeechSynthesisUtterance.h>
#include <LibWeb/Bindings/SpeechSynthesisVoice.h>
#include <LibWeb/Bindings/StorageManager.h>
#include <LibWeb/Bindings/ByteLengthQueuingStrategy.h>
#include <LibWeb/Bindings/CountQueuingStrategy.h>
#include <LibWeb/Bindings/ReadableByteStreamController.h>
#include <LibWeb/Bindings/ReadableStream.h>
#include <LibWeb/Bindings/ReadableStreamBYOBReader.h>
#include <LibWeb/Bindings/ReadableStreamBYOBRequest.h>
#include <LibWeb/Bindings/ReadableStreamDefaultController.h>
#include <LibWeb/Bindings/ReadableStreamDefaultReader.h>
#include <LibWeb/Bindings/TransformStream.h>
#include <LibWeb/Bindings/TransformStreamDefaultController.h>
#include <LibWeb/Bindings/WritableStream.h>
#include <LibWeb/Bindings/WritableStreamDefaultController.h>
#include <LibWeb/Bindings/WritableStreamDefaultWriter.h>
#include <LibWeb/Bindings/SVGAElement.h>
#include <LibWeb/Bindings/SVGAnimatedEnumeration.h>
#include <LibWeb/Bindings/SVGAnimatedInteger.h>
#include <LibWeb/Bindings/SVGAnimatedLength.h>
#include <LibWeb/Bindings/SVGAnimatedLengthList.h>
#include <LibWeb/Bindings/SVGAnimatedNumber.h>
#include <LibWeb/Bindings/SVGAnimatedNumberList.h>
#include <LibWeb/Bindings/SVGAnimatedRect.h>
#include <LibWeb/Bindings/SVGAnimatedString.h>
#include <LibWeb/Bindings/SVGAnimatedTransformList.h>
#include <LibWeb/Bindings/SVGAnimationElement.h>
#include <LibWeb/Bindings/SVGCircleElement.h>
#include <LibWeb/Bindings/SVGClipPathElement.h>
#include <LibWeb/Bindings/SVGComponentTransferFunctionElement.h>
#include <LibWeb/Bindings/SVGDefsElement.h>
#include <LibWeb/Bindings/SVGDescElement.h>
#include <LibWeb/Bindings/SVGElement.h>
#include <LibWeb/Bindings/SVGEllipseElement.h>
#include <LibWeb/Bindings/SVGFEBlendElement.h>
#include <LibWeb/Bindings/SVGFEColorMatrixElement.h>
#include <LibWeb/Bindings/SVGFEComponentTransferElement.h>
#include <LibWeb/Bindings/SVGFECompositeElement.h>
#include <LibWeb/Bindings/SVGFEDisplacementMapElement.h>
#include <LibWeb/Bindings/SVGFEDropShadowElement.h>
#include <LibWeb/Bindings/SVGFEFloodElement.h>
#include <LibWeb/Bindings/SVGFEFuncAElement.h>
#include <LibWeb/Bindings/SVGFEFuncBElement.h>
#include <LibWeb/Bindings/SVGFEFuncGElement.h>
#include <LibWeb/Bindings/SVGFEFuncRElement.h>
#include <LibWeb/Bindings/SVGFEGaussianBlurElement.h>
#include <LibWeb/Bindings/SVGFEImageElement.h>
#include <LibWeb/Bindings/SVGFEMergeElement.h>
#include <LibWeb/Bindings/SVGFEMergeNodeElement.h>
#include <LibWeb/Bindings/SVGFEMorphologyElement.h>
#include <LibWeb/Bindings/SVGFEOffsetElement.h>
#include <LibWeb/Bindings/SVGFETurbulenceElement.h>
#include <LibWeb/Bindings/SVGFilterElement.h>
#include <LibWeb/Bindings/SVGForeignObjectElement.h>
#include <LibWeb/Bindings/SVGGElement.h>
#include <LibWeb/Bindings/SVGGeometryElement.h>
#include <LibWeb/Bindings/SVGGradientElement.h>
#include <LibWeb/Bindings/SVGGraphicsElement.h>
#include <LibWeb/Bindings/SVGImageElement.h>
#include <LibWeb/Bindings/SVGLength.h>
#include <LibWeb/Bindings/SVGLengthList.h>
#include <LibWeb/Bindings/SVGLinearGradientElement.h>
#include <LibWeb/Bindings/SVGLineElement.h>
#include <LibWeb/Bindings/SVGMaskElement.h>
#include <LibWeb/Bindings/SVGMetadataElement.h>
#include <LibWeb/Bindings/SVGNumber.h>
#include <LibWeb/Bindings/SVGNumberList.h>
#include <LibWeb/Bindings/SVGPathElement.h>
#include <LibWeb/Bindings/SVGPatternElement.h>
#include <LibWeb/Bindings/SVGPolygonElement.h>
#include <LibWeb/Bindings/SVGPolylineElement.h>
#include <LibWeb/Bindings/SVGRadialGradientElement.h>
#include <LibWeb/Bindings/SVGRectElement.h>
#include <LibWeb/Bindings/SVGScriptElement.h>
#include <LibWeb/Bindings/SVGStopElement.h>
#include <LibWeb/Bindings/SVGStyleElement.h>
#include <LibWeb/Bindings/SVGSVGElement.h>
#include <LibWeb/Bindings/SVGSymbolElement.h>
#include <LibWeb/Bindings/SVGTextContentElement.h>
#include <LibWeb/Bindings/SVGTextElement.h>
#include <LibWeb/Bindings/SVGTextPathElement.h>
#include <LibWeb/Bindings/SVGTextPositioningElement.h>
#include <LibWeb/Bindings/SVGTitleElement.h>
#include <LibWeb/Bindings/SVGTransform.h>
#include <LibWeb/Bindings/SVGTransformList.h>
#include <LibWeb/Bindings/SVGTSpanElement.h>
#include <LibWeb/Bindings/SVGUnitTypes.h>
#include <LibWeb/Bindings/SVGUseElement.h>
#include <LibWeb/Bindings/SVGViewElement.h>
#include <LibWeb/Bindings/TrustedHTML.h>
#include <LibWeb/Bindings/TrustedScript.h>
#include <LibWeb/Bindings/TrustedScriptURL.h>
#include <LibWeb/Bindings/TrustedTypePolicy.h>
#include <LibWeb/Bindings/TrustedTypePolicyFactory.h>
#include <LibWeb/Bindings/CompositionEvent.h>
#include <LibWeb/Bindings/FocusEvent.h>
#include <LibWeb/Bindings/InputEvent.h>
#include <LibWeb/Bindings/KeyboardEvent.h>
#include <LibWeb/Bindings/MouseEvent.h>
#include <LibWeb/Bindings/PointerEvent.h>
#include <LibWeb/Bindings/TextEvent.h>
#include <LibWeb/Bindings/UIEvent.h>
#include <LibWeb/Bindings/WheelEvent.h>
#include <LibWeb/Bindings/URLPattern.h>
#include <LibWeb/Bindings/PerformanceMark.h>
#include <LibWeb/Bindings/PerformanceMeasure.h>
#include <LibWeb/Bindings/ViewTransition.h>
#include <LibWeb/Bindings/Global.h>
#include <LibWeb/Bindings/Instance.h>
#include <LibWeb/Bindings/Memory.h>
#include <LibWeb/Bindings/Module.h>
#include <LibWeb/Bindings/Table.h>
#include <LibWeb/Bindings/WebAssembly.h>
#include <LibWeb/Bindings/AnalyserNode.h>
#include <LibWeb/Bindings/AudioBuffer.h>
#include <LibWeb/Bindings/AudioBufferSourceNode.h>
#include <LibWeb/Bindings/AudioContext.h>
#include <LibWeb/Bindings/AudioDestinationNode.h>
#include <LibWeb/Bindings/AudioListener.h>
#include <LibWeb/Bindings/AudioNode.h>
#include <LibWeb/Bindings/AudioParam.h>
#include <LibWeb/Bindings/AudioScheduledSourceNode.h>
#include <LibWeb/Bindings/BaseAudioContext.h>
#include <LibWeb/Bindings/BiquadFilterNode.h>
#include <LibWeb/Bindings/ChannelMergerNode.h>
#include <LibWeb/Bindings/ChannelSplitterNode.h>
#include <LibWeb/Bindings/ConstantSourceNode.h>
#include <LibWeb/Bindings/DelayNode.h>
#include <LibWeb/Bindings/DynamicsCompressorNode.h>
#include <LibWeb/Bindings/GainNode.h>
#include <LibWeb/Bindings/MediaElementAudioSourceNode.h>
#include <LibWeb/Bindings/OfflineAudioCompletionEvent.h>
#include <LibWeb/Bindings/OfflineAudioContext.h>
#include <LibWeb/Bindings/OscillatorNode.h>
#include <LibWeb/Bindings/PannerNode.h>
#include <LibWeb/Bindings/PeriodicWave.h>
#include <LibWeb/Bindings/ScriptProcessorNode.h>
#include <LibWeb/Bindings/StereoPannerNode.h>
#include <LibWeb/Bindings/ANGLEInstancedArrays.h>
#include <LibWeb/Bindings/EXTBlendMinMax.h>
#include <LibWeb/Bindings/EXTColorBufferFloat.h>
#include <LibWeb/Bindings/EXTRenderSnorm.h>
#include <LibWeb/Bindings/EXTTextureFilterAnisotropic.h>
#include <LibWeb/Bindings/EXTTextureNorm16.h>
#include <LibWeb/Bindings/OESElementIndexUint.h>
#include <LibWeb/Bindings/OESStandardDerivatives.h>
#include <LibWeb/Bindings/OESVertexArrayObject.h>
#include <LibWeb/Bindings/WebGLCompressedTextureS3tc.h>
#include <LibWeb/Bindings/WebGLCompressedTextureS3tcSrgb.h>
#include <LibWeb/Bindings/WebGLDebugRendererInfo.h>
#include <LibWeb/Bindings/WebGLDrawBuffers.h>
#include <LibWeb/Bindings/WebGLVertexArrayObjectOES.h>
#include <LibWeb/Bindings/WebGL2RenderingContext.h>
#include <LibWeb/Bindings/WebGLActiveInfo.h>
#include <LibWeb/Bindings/WebGLBuffer.h>
#include <LibWeb/Bindings/WebGLContextEvent.h>
#include <LibWeb/Bindings/WebGLFramebuffer.h>
#include <LibWeb/Bindings/WebGLObject.h>
#include <LibWeb/Bindings/WebGLProgram.h>
#include <LibWeb/Bindings/WebGLQuery.h>
#include <LibWeb/Bindings/WebGLRenderbuffer.h>
#include <LibWeb/Bindings/WebGLRenderingContext.h>
#include <LibWeb/Bindings/WebGLSampler.h>
#include <LibWeb/Bindings/WebGLShader.h>
#include <LibWeb/Bindings/WebGLShaderPrecisionFormat.h>
#include <LibWeb/Bindings/WebGLSync.h>
#include <LibWeb/Bindings/WebGLTexture.h>
#include <LibWeb/Bindings/WebGLTransformFeedback.h>
#include <LibWeb/Bindings/WebGLUniformLocation.h>
#include <LibWeb/Bindings/WebGLVertexArrayObject.h>
#include <LibWeb/Bindings/DOMException.h>
#include <LibWeb/Bindings/QuotaExceededError.h>
#include <LibWeb/Bindings/WebSocket.h>
#include <LibWeb/Bindings/VTTCue.h>
#include <LibWeb/Bindings/VTTRegion.h>
#include <LibWeb/Bindings/XRLayer.h>
#include <LibWeb/Bindings/XRRenderState.h>
#include <LibWeb/Bindings/XRSession.h>
#include <LibWeb/Bindings/XRSessionEvent.h>
#include <LibWeb/Bindings/XRSystem.h>
#include <LibWeb/Bindings/XRWebGLLayer.h>
#include <LibWeb/Bindings/FormData.h>
#include <LibWeb/Bindings/ProgressEvent.h>
#include <LibWeb/Bindings/XMLHttpRequest.h>
#include <LibWeb/Bindings/XMLHttpRequestEventTarget.h>
#include <LibWeb/Bindings/XMLHttpRequestUpload.h>
#include <LibWeb/Bindings/XPathEvaluator.h>
#include <LibWeb/Bindings/XPathExpression.h>
#include <LibWeb/Bindings/XPathResult.h>

namespace Web::Bindings {
static constexpr bool is_secure_context_interface(InterfaceName name)
{
    switch (name) {
    case InterfaceName::Clipboard:
    case InterfaceName::ClipboardItem:
    case InterfaceName::CookieChangeEvent:
    case InterfaceName::CookieStore:
    case InterfaceName::Credential:
    case InterfaceName::CredentialsContainer:
    case InterfaceName::FederatedCredential:
    case InterfaceName::PasswordCredential:
    case InterfaceName::CryptoKey:
    case InterfaceName::SubtleCrypto:
    case InterfaceName::MediaKeySystemAccess:
    case InterfaceName::GeolocationCoordinates:
    case InterfaceName::GeolocationPosition:
    case InterfaceName::WorkletGlobalScope:
    case InterfaceName::MediaDeviceInfo:
    case InterfaceName::MediaDevices:
    case InterfaceName::Serial:
    case InterfaceName::SerialPort:
    case InterfaceName::Cache:
    case InterfaceName::CacheStorage:
    case InterfaceName::ServiceWorker:
    case InterfaceName::ServiceWorkerContainer:
    case InterfaceName::ServiceWorkerGlobalScope:
    case InterfaceName::ServiceWorkerRegistration:
    case InterfaceName::StorageManager:
    case InterfaceName::XRLayer:
    case InterfaceName::XRRenderState:
    case InterfaceName::XRSession:
    case InterfaceName::XRSessionEvent:
    case InterfaceName::XRSystem:
    case InterfaceName::XRWebGLLayer:
        return true;
    default:
        return false;
    }
}
static constexpr bool is_experimental_interface(InterfaceName name)
{
    switch (name) {
    case InterfaceName::OffscreenCanvas:
    case InterfaceName::OffscreenCanvasRenderingContext2D:
    case InterfaceName::ManagedMediaSource:
    case InterfaceName::MediaSource:
    case InterfaceName::MediaSourceHandle:
    case InterfaceName::PermissionStatus:
    case InterfaceName::XRLayer:
    case InterfaceName::XRRenderState:
    case InterfaceName::XRSession:
    case InterfaceName::XRSessionEvent:
    case InterfaceName::XRSystem:
    case InterfaceName::XRWebGLLayer:
        return true;
    default:
        return false;
    }
}
static constexpr bool is_window_exposed(InterfaceName name)
{
    switch (name) {
    case InterfaceName::Animation:
    case InterfaceName::AnimationEffect:
    case InterfaceName::AnimationPlaybackEvent:
    case InterfaceName::AnimationTimeline:
    case InterfaceName::DocumentTimeline:
    case InterfaceName::KeyframeEffect:
    case InterfaceName::ScrollTimeline:
    case InterfaceName::Clipboard:
    case InterfaceName::ClipboardEvent:
    case InterfaceName::ClipboardItem:
    case InterfaceName::CompressionStream:
    case InterfaceName::DecompressionStream:
    case InterfaceName::SecurityPolicyViolationEvent:
    case InterfaceName::CookieChangeEvent:
    case InterfaceName::CookieStore:
    case InterfaceName::Credential:
    case InterfaceName::CredentialsContainer:
    case InterfaceName::FederatedCredential:
    case InterfaceName::PasswordCredential:
    case InterfaceName::Crypto:
    case InterfaceName::CryptoKey:
    case InterfaceName::SubtleCrypto:
    case InterfaceName::AnimationEvent:
    case InterfaceName::CSS:
    case InterfaceName::CSSAnimation:
    case InterfaceName::CSSConditionRule:
    case InterfaceName::CSSContainerRule:
    case InterfaceName::CSSCounterStyleRule:
    case InterfaceName::CSSFontFaceDescriptors:
    case InterfaceName::CSSFontFaceRule:
    case InterfaceName::CSSFontFeatureValuesMap:
    case InterfaceName::CSSFontFeatureValuesRule:
    case InterfaceName::CSSFunctionDeclarations:
    case InterfaceName::CSSFunctionDescriptors:
    case InterfaceName::CSSFunctionRule:
    case InterfaceName::CSSGroupingRule:
    case InterfaceName::CSSImageValue:
    case InterfaceName::CSSImportRule:
    case InterfaceName::CSSKeyframeRule:
    case InterfaceName::CSSKeyframesRule:
    case InterfaceName::CSSKeywordValue:
    case InterfaceName::CSSLayerBlockRule:
    case InterfaceName::CSSLayerStatementRule:
    case InterfaceName::CSSMarginRule:
    case InterfaceName::CSSMathClamp:
    case InterfaceName::CSSMathInvert:
    case InterfaceName::CSSMathMax:
    case InterfaceName::CSSMathMin:
    case InterfaceName::CSSMathNegate:
    case InterfaceName::CSSMathProduct:
    case InterfaceName::CSSMathSum:
    case InterfaceName::CSSMathValue:
    case InterfaceName::CSSMatrixComponent:
    case InterfaceName::CSSMediaRule:
    case InterfaceName::CSSNamespaceRule:
    case InterfaceName::CSSNestedDeclarations:
    case InterfaceName::CSSNumericArray:
    case InterfaceName::CSSNumericValue:
    case InterfaceName::CSSPageDescriptors:
    case InterfaceName::CSSPageRule:
    case InterfaceName::CSSPerspective:
    case InterfaceName::CSSPropertyRule:
    case InterfaceName::CSSRotate:
    case InterfaceName::CSSRule:
    case InterfaceName::CSSRuleList:
    case InterfaceName::CSSScale:
    case InterfaceName::CSSSkew:
    case InterfaceName::CSSSkewX:
    case InterfaceName::CSSSkewY:
    case InterfaceName::CSSStyleDeclaration:
    case InterfaceName::CSSStyleProperties:
    case InterfaceName::CSSStyleRule:
    case InterfaceName::CSSStyleSheet:
    case InterfaceName::CSSStyleValue:
    case InterfaceName::CSSSupportsRule:
    case InterfaceName::CSSTransformComponent:
    case InterfaceName::CSSTransformValue:
    case InterfaceName::CSSTransition:
    case InterfaceName::CSSTranslate:
    case InterfaceName::CSSUnitValue:
    case InterfaceName::CSSUnparsedValue:
    case InterfaceName::CSSVariableReferenceValue:
    case InterfaceName::FontFace:
    case InterfaceName::FontFaceSet:
    case InterfaceName::FontFaceSetLoadEvent:
    case InterfaceName::MediaList:
    case InterfaceName::MediaQueryList:
    case InterfaceName::MediaQueryListEvent:
    case InterfaceName::Screen:
    case InterfaceName::ScreenOrientation:
    case InterfaceName::StylePropertyMap:
    case InterfaceName::StylePropertyMapReadOnly:
    case InterfaceName::StyleSheet:
    case InterfaceName::StyleSheetList:
    case InterfaceName::TransitionEvent:
    case InterfaceName::VisualViewport:
    case InterfaceName::AbortController:
    case InterfaceName::AbortSignal:
    case InterfaceName::AbstractRange:
    case InterfaceName::Attr:
    case InterfaceName::CDATASection:
    case InterfaceName::CharacterData:
    case InterfaceName::Comment:
    case InterfaceName::CustomEvent:
    case InterfaceName::Document:
    case InterfaceName::DocumentFragment:
    case InterfaceName::DocumentType:
    case InterfaceName::DOMImplementation:
    case InterfaceName::DOMTokenList:
    case InterfaceName::Element:
    case InterfaceName::Event:
    case InterfaceName::EventTarget:
    case InterfaceName::HTMLCollection:
    case InterfaceName::MutationObserver:
    case InterfaceName::MutationRecord:
    case InterfaceName::NamedNodeMap:
    case InterfaceName::Node:
    case InterfaceName::NodeFilter:
    case InterfaceName::NodeIterator:
    case InterfaceName::NodeList:
    case InterfaceName::ProcessingInstruction:
    case InterfaceName::Range:
    case InterfaceName::ShadowRoot:
    case InterfaceName::StaticRange:
    case InterfaceName::Text:
    case InterfaceName::TreeWalker:
    case InterfaceName::XMLDocument:
    case InterfaceName::URL:
    case InterfaceName::Origin:
    case InterfaceName::URLSearchParams:
    case InterfaceName::TextDecoder:
    case InterfaceName::TextDecoderStream:
    case InterfaceName::TextEncoder:
    case InterfaceName::TextEncoderStream:
    case InterfaceName::MediaKeySystemAccess:
    case InterfaceName::FileSystemEntry:
    case InterfaceName::PerformanceEventTiming:
    case InterfaceName::Headers:
    case InterfaceName::Request:
    case InterfaceName::Response:
    case InterfaceName::Blob:
    case InterfaceName::File:
    case InterfaceName::FileList:
    case InterfaceName::FileReader:
    case InterfaceName::Gamepad:
    case InterfaceName::GamepadButton:
    case InterfaceName::GamepadEvent:
    case InterfaceName::GamepadHapticActuator:
    case InterfaceName::Geolocation:
    case InterfaceName::GeolocationCoordinates:
    case InterfaceName::GeolocationPosition:
    case InterfaceName::GeolocationPositionError:
    case InterfaceName::DOMMatrix:
    case InterfaceName::DOMMatrixReadOnly:
    case InterfaceName::DOMPoint:
    case InterfaceName::DOMPointReadOnly:
    case InterfaceName::DOMQuad:
    case InterfaceName::DOMRect:
    case InterfaceName::DOMRectList:
    case InterfaceName::DOMRectReadOnly:
    case InterfaceName::Performance:
    case InterfaceName::AudioTrack:
    case InterfaceName::AudioTrackList:
    case InterfaceName::BarProp:
    case InterfaceName::BeforeUnloadEvent:
    case InterfaceName::BroadcastChannel:
    case InterfaceName::CanvasGradient:
    case InterfaceName::CanvasPattern:
    case InterfaceName::CanvasRenderingContext2D:
    case InterfaceName::CloseEvent:
    case InterfaceName::CloseWatcher:
    case InterfaceName::CommandEvent:
    case InterfaceName::CustomElementRegistry:
    case InterfaceName::CustomStateSet:
    case InterfaceName::DataTransfer:
    case InterfaceName::DataTransferItem:
    case InterfaceName::DataTransferItemList:
    case InterfaceName::DOMParser:
    case InterfaceName::DOMStringList:
    case InterfaceName::DOMStringMap:
    case InterfaceName::DragEvent:
    case InterfaceName::ElementInternals:
    case InterfaceName::ErrorEvent:
    case InterfaceName::EventSource:
    case InterfaceName::External:
    case InterfaceName::FormDataEvent:
    case InterfaceName::HashChangeEvent:
    case InterfaceName::History:
    case InterfaceName::HTMLAllCollection:
    case InterfaceName::HTMLAnchorElement:
    case InterfaceName::HTMLAreaElement:
    case InterfaceName::HTMLAudioElement:
    case InterfaceName::HTMLBaseElement:
    case InterfaceName::HTMLBodyElement:
    case InterfaceName::HTMLBRElement:
    case InterfaceName::HTMLButtonElement:
    case InterfaceName::HTMLCanvasElement:
    case InterfaceName::HTMLDataElement:
    case InterfaceName::HTMLDataListElement:
    case InterfaceName::HTMLDetailsElement:
    case InterfaceName::HTMLDialogElement:
    case InterfaceName::HTMLDirectoryElement:
    case InterfaceName::HTMLDivElement:
    case InterfaceName::HTMLDListElement:
    case InterfaceName::HTMLDocument:
    case InterfaceName::HTMLElement:
    case InterfaceName::HTMLEmbedElement:
    case InterfaceName::HTMLFieldSetElement:
    case InterfaceName::HTMLFontElement:
    case InterfaceName::HTMLFormControlsCollection:
    case InterfaceName::HTMLFormElement:
    case InterfaceName::HTMLFrameElement:
    case InterfaceName::HTMLFrameSetElement:
    case InterfaceName::HTMLHeadElement:
    case InterfaceName::HTMLHeadingElement:
    case InterfaceName::HTMLHRElement:
    case InterfaceName::HTMLHtmlElement:
    case InterfaceName::HTMLIFrameElement:
    case InterfaceName::HTMLImageElement:
    case InterfaceName::HTMLInputElement:
    case InterfaceName::HTMLLabelElement:
    case InterfaceName::HTMLLegendElement:
    case InterfaceName::HTMLLIElement:
    case InterfaceName::HTMLLinkElement:
    case InterfaceName::HTMLMapElement:
    case InterfaceName::HTMLMarqueeElement:
    case InterfaceName::HTMLMediaElement:
    case InterfaceName::HTMLMenuElement:
    case InterfaceName::HTMLMetaElement:
    case InterfaceName::HTMLMeterElement:
    case InterfaceName::HTMLModElement:
    case InterfaceName::HTMLObjectElement:
    case InterfaceName::HTMLOListElement:
    case InterfaceName::HTMLOptGroupElement:
    case InterfaceName::HTMLOptionElement:
    case InterfaceName::HTMLOptionsCollection:
    case InterfaceName::HTMLOutputElement:
    case InterfaceName::HTMLParagraphElement:
    case InterfaceName::HTMLParamElement:
    case InterfaceName::HTMLPictureElement:
    case InterfaceName::HTMLPreElement:
    case InterfaceName::HTMLProgressElement:
    case InterfaceName::HTMLQuoteElement:
    case InterfaceName::HTMLScriptElement:
    case InterfaceName::HTMLSelectedContentElement:
    case InterfaceName::HTMLSelectElement:
    case InterfaceName::HTMLSlotElement:
    case InterfaceName::HTMLSourceElement:
    case InterfaceName::HTMLSpanElement:
    case InterfaceName::HTMLStyleElement:
    case InterfaceName::HTMLTableCaptionElement:
    case InterfaceName::HTMLTableCellElement:
    case InterfaceName::HTMLTableColElement:
    case InterfaceName::HTMLTableElement:
    case InterfaceName::HTMLTableRowElement:
    case InterfaceName::HTMLTableSectionElement:
    case InterfaceName::HTMLTemplateElement:
    case InterfaceName::HTMLTextAreaElement:
    case InterfaceName::HTMLTimeElement:
    case InterfaceName::HTMLTitleElement:
    case InterfaceName::HTMLTrackElement:
    case InterfaceName::HTMLUListElement:
    case InterfaceName::HTMLUnknownElement:
    case InterfaceName::HTMLVideoElement:
    case InterfaceName::ImageBitmap:
    case InterfaceName::ImageData:
    case InterfaceName::Location:
    case InterfaceName::MediaError:
    case InterfaceName::MessageChannel:
    case InterfaceName::MessageEvent:
    case InterfaceName::MessagePort:
    case InterfaceName::MimeType:
    case InterfaceName::MimeTypeArray:
    case InterfaceName::NavigateEvent:
    case InterfaceName::Navigation:
    case InterfaceName::NavigationCurrentEntryChangeEvent:
    case InterfaceName::NavigationDestination:
    case InterfaceName::NavigationHistoryEntry:
    case InterfaceName::NavigationTransition:
    case InterfaceName::Navigator:
    case InterfaceName::OffscreenCanvas:
    case InterfaceName::OffscreenCanvasRenderingContext2D:
    case InterfaceName::PageTransitionEvent:
    case InterfaceName::Path2D:
    case InterfaceName::Plugin:
    case InterfaceName::PluginArray:
    case InterfaceName::PopStateEvent:
    case InterfaceName::PromiseRejectionEvent:
    case InterfaceName::RadioNodeList:
    case InterfaceName::SharedWorker:
    case InterfaceName::Storage:
    case InterfaceName::StorageEvent:
    case InterfaceName::SubmitEvent:
    case InterfaceName::TextMetrics:
    case InterfaceName::TextTrack:
    case InterfaceName::TextTrackCue:
    case InterfaceName::TextTrackCueList:
    case InterfaceName::TextTrackList:
    case InterfaceName::TimeRanges:
    case InterfaceName::ToggleEvent:
    case InterfaceName::TrackEvent:
    case InterfaceName::UserActivation:
    case InterfaceName::ValidityState:
    case InterfaceName::VideoTrack:
    case InterfaceName::VideoTrackList:
    case InterfaceName::Window:
    case InterfaceName::Worker:
    case InterfaceName::XMLSerializer:
    case InterfaceName::IDBCursor:
    case InterfaceName::IDBCursorWithValue:
    case InterfaceName::IDBDatabase:
    case InterfaceName::IDBFactory:
    case InterfaceName::IDBIndex:
    case InterfaceName::IDBKeyRange:
    case InterfaceName::IDBObjectStore:
    case InterfaceName::IDBOpenDBRequest:
    case InterfaceName::IDBRecord:
    case InterfaceName::IDBRequest:
    case InterfaceName::IDBTransaction:
    case InterfaceName::IDBVersionChangeEvent:
    case InterfaceName::IntersectionObserver:
    case InterfaceName::IntersectionObserverEntry:
    case InterfaceName::MathMLElement:
    case InterfaceName::MediaCapabilities:
    case InterfaceName::MediaDeviceInfo:
    case InterfaceName::MediaDevices:
    case InterfaceName::MediaStream:
    case InterfaceName::MediaStreamTrack:
    case InterfaceName::MediaStreamTrackEvent:
    case InterfaceName::BufferedChangeEvent:
    case InterfaceName::ManagedMediaSource:
    case InterfaceName::ManagedSourceBuffer:
    case InterfaceName::MediaSource:
    case InterfaceName::MediaSourceHandle:
    case InterfaceName::SourceBuffer:
    case InterfaceName::SourceBufferList:
    case InterfaceName::PerformanceNavigation:
    case InterfaceName::PerformanceTiming:
    case InterfaceName::Notification:
    case InterfaceName::PerformanceEntry:
    case InterfaceName::PerformanceObserver:
    case InterfaceName::PerformanceObserverEntryList:
    case InterfaceName::Permissions:
    case InterfaceName::PermissionStatus:
    case InterfaceName::IdleDeadline:
    case InterfaceName::ResizeObserver:
    case InterfaceName::ResizeObserverEntry:
    case InterfaceName::ResizeObserverSize:
    case InterfaceName::PerformanceResourceTiming:
    case InterfaceName::Selection:
    case InterfaceName::Serial:
    case InterfaceName::SerialPort:
    case InterfaceName::Cache:
    case InterfaceName::CacheStorage:
    case InterfaceName::ServiceWorker:
    case InterfaceName::ServiceWorkerContainer:
    case InterfaceName::ServiceWorkerRegistration:
    case InterfaceName::SpeechGrammar:
    case InterfaceName::SpeechGrammarList:
    case InterfaceName::SpeechRecognition:
    case InterfaceName::SpeechRecognitionAlternative:
    case InterfaceName::SpeechRecognitionEvent:
    case InterfaceName::SpeechRecognitionPhrase:
    case InterfaceName::SpeechRecognitionResult:
    case InterfaceName::SpeechRecognitionResultList:
    case InterfaceName::SpeechSynthesis:
    case InterfaceName::SpeechSynthesisUtterance:
    case InterfaceName::SpeechSynthesisVoice:
    case InterfaceName::StorageManager:
    case InterfaceName::ByteLengthQueuingStrategy:
    case InterfaceName::CountQueuingStrategy:
    case InterfaceName::ReadableByteStreamController:
    case InterfaceName::ReadableStream:
    case InterfaceName::ReadableStreamBYOBReader:
    case InterfaceName::ReadableStreamBYOBRequest:
    case InterfaceName::ReadableStreamDefaultController:
    case InterfaceName::ReadableStreamDefaultReader:
    case InterfaceName::TransformStream:
    case InterfaceName::TransformStreamDefaultController:
    case InterfaceName::WritableStream:
    case InterfaceName::WritableStreamDefaultController:
    case InterfaceName::WritableStreamDefaultWriter:
    case InterfaceName::SVGAElement:
    case InterfaceName::SVGAnimatedEnumeration:
    case InterfaceName::SVGAnimatedInteger:
    case InterfaceName::SVGAnimatedLength:
    case InterfaceName::SVGAnimatedLengthList:
    case InterfaceName::SVGAnimatedNumber:
    case InterfaceName::SVGAnimatedNumberList:
    case InterfaceName::SVGAnimatedRect:
    case InterfaceName::SVGAnimatedString:
    case InterfaceName::SVGAnimatedTransformList:
    case InterfaceName::SVGAnimationElement:
    case InterfaceName::SVGCircleElement:
    case InterfaceName::SVGClipPathElement:
    case InterfaceName::SVGComponentTransferFunctionElement:
    case InterfaceName::SVGDefsElement:
    case InterfaceName::SVGDescElement:
    case InterfaceName::SVGElement:
    case InterfaceName::SVGEllipseElement:
    case InterfaceName::SVGFEBlendElement:
    case InterfaceName::SVGFEColorMatrixElement:
    case InterfaceName::SVGFEComponentTransferElement:
    case InterfaceName::SVGFECompositeElement:
    case InterfaceName::SVGFEDisplacementMapElement:
    case InterfaceName::SVGFEDropShadowElement:
    case InterfaceName::SVGFEFloodElement:
    case InterfaceName::SVGFEFuncAElement:
    case InterfaceName::SVGFEFuncBElement:
    case InterfaceName::SVGFEFuncGElement:
    case InterfaceName::SVGFEFuncRElement:
    case InterfaceName::SVGFEGaussianBlurElement:
    case InterfaceName::SVGFEImageElement:
    case InterfaceName::SVGFEMergeElement:
    case InterfaceName::SVGFEMergeNodeElement:
    case InterfaceName::SVGFEMorphologyElement:
    case InterfaceName::SVGFEOffsetElement:
    case InterfaceName::SVGFETurbulenceElement:
    case InterfaceName::SVGFilterElement:
    case InterfaceName::SVGForeignObjectElement:
    case InterfaceName::SVGGElement:
    case InterfaceName::SVGGeometryElement:
    case InterfaceName::SVGGradientElement:
    case InterfaceName::SVGGraphicsElement:
    case InterfaceName::SVGImageElement:
    case InterfaceName::SVGLength:
    case InterfaceName::SVGLengthList:
    case InterfaceName::SVGLinearGradientElement:
    case InterfaceName::SVGLineElement:
    case InterfaceName::SVGMaskElement:
    case InterfaceName::SVGMetadataElement:
    case InterfaceName::SVGNumber:
    case InterfaceName::SVGNumberList:
    case InterfaceName::SVGPathElement:
    case InterfaceName::SVGPatternElement:
    case InterfaceName::SVGPolygonElement:
    case InterfaceName::SVGPolylineElement:
    case InterfaceName::SVGRadialGradientElement:
    case InterfaceName::SVGRectElement:
    case InterfaceName::SVGScriptElement:
    case InterfaceName::SVGStopElement:
    case InterfaceName::SVGStyleElement:
    case InterfaceName::SVGSVGElement:
    case InterfaceName::SVGSymbolElement:
    case InterfaceName::SVGTextContentElement:
    case InterfaceName::SVGTextElement:
    case InterfaceName::SVGTextPathElement:
    case InterfaceName::SVGTextPositioningElement:
    case InterfaceName::SVGTitleElement:
    case InterfaceName::SVGTransform:
    case InterfaceName::SVGTransformList:
    case InterfaceName::SVGTSpanElement:
    case InterfaceName::SVGUnitTypes:
    case InterfaceName::SVGUseElement:
    case InterfaceName::SVGViewElement:
    case InterfaceName::TrustedHTML:
    case InterfaceName::TrustedScript:
    case InterfaceName::TrustedScriptURL:
    case InterfaceName::TrustedTypePolicy:
    case InterfaceName::TrustedTypePolicyFactory:
    case InterfaceName::CompositionEvent:
    case InterfaceName::FocusEvent:
    case InterfaceName::InputEvent:
    case InterfaceName::KeyboardEvent:
    case InterfaceName::MouseEvent:
    case InterfaceName::PointerEvent:
    case InterfaceName::TextEvent:
    case InterfaceName::UIEvent:
    case InterfaceName::WheelEvent:
    case InterfaceName::URLPattern:
    case InterfaceName::PerformanceMark:
    case InterfaceName::PerformanceMeasure:
    case InterfaceName::ViewTransition:
    case InterfaceName::Global:
    case InterfaceName::Instance:
    case InterfaceName::Memory:
    case InterfaceName::Module:
    case InterfaceName::Table:
    case InterfaceName::WebAssembly:
    case InterfaceName::AnalyserNode:
    case InterfaceName::AudioBuffer:
    case InterfaceName::AudioBufferSourceNode:
    case InterfaceName::AudioContext:
    case InterfaceName::AudioDestinationNode:
    case InterfaceName::AudioListener:
    case InterfaceName::AudioNode:
    case InterfaceName::AudioParam:
    case InterfaceName::AudioScheduledSourceNode:
    case InterfaceName::BaseAudioContext:
    case InterfaceName::BiquadFilterNode:
    case InterfaceName::ChannelMergerNode:
    case InterfaceName::ChannelSplitterNode:
    case InterfaceName::ConstantSourceNode:
    case InterfaceName::DelayNode:
    case InterfaceName::DynamicsCompressorNode:
    case InterfaceName::GainNode:
    case InterfaceName::MediaElementAudioSourceNode:
    case InterfaceName::OfflineAudioCompletionEvent:
    case InterfaceName::OfflineAudioContext:
    case InterfaceName::OscillatorNode:
    case InterfaceName::PannerNode:
    case InterfaceName::PeriodicWave:
    case InterfaceName::ScriptProcessorNode:
    case InterfaceName::StereoPannerNode:
    case InterfaceName::ANGLEInstancedArrays:
    case InterfaceName::EXTBlendMinMax:
    case InterfaceName::EXTColorBufferFloat:
    case InterfaceName::EXTRenderSnorm:
    case InterfaceName::EXTTextureFilterAnisotropic:
    case InterfaceName::EXTTextureNorm16:
    case InterfaceName::OESElementIndexUint:
    case InterfaceName::OESStandardDerivatives:
    case InterfaceName::OESVertexArrayObject:
    case InterfaceName::WebGLCompressedTextureS3tc:
    case InterfaceName::WebGLCompressedTextureS3tcSrgb:
    case InterfaceName::WebGLDebugRendererInfo:
    case InterfaceName::WebGLDrawBuffers:
    case InterfaceName::WebGLVertexArrayObjectOES:
    case InterfaceName::WebGL2RenderingContext:
    case InterfaceName::WebGLActiveInfo:
    case InterfaceName::WebGLBuffer:
    case InterfaceName::WebGLContextEvent:
    case InterfaceName::WebGLFramebuffer:
    case InterfaceName::WebGLObject:
    case InterfaceName::WebGLProgram:
    case InterfaceName::WebGLQuery:
    case InterfaceName::WebGLRenderbuffer:
    case InterfaceName::WebGLRenderingContext:
    case InterfaceName::WebGLSampler:
    case InterfaceName::WebGLShader:
    case InterfaceName::WebGLShaderPrecisionFormat:
    case InterfaceName::WebGLSync:
    case InterfaceName::WebGLTexture:
    case InterfaceName::WebGLTransformFeedback:
    case InterfaceName::WebGLUniformLocation:
    case InterfaceName::WebGLVertexArrayObject:
    case InterfaceName::DOMException:
    case InterfaceName::QuotaExceededError:
    case InterfaceName::WebSocket:
    case InterfaceName::VTTCue:
    case InterfaceName::VTTRegion:
    case InterfaceName::XRLayer:
    case InterfaceName::XRRenderState:
    case InterfaceName::XRSession:
    case InterfaceName::XRSessionEvent:
    case InterfaceName::XRSystem:
    case InterfaceName::XRWebGLLayer:
    case InterfaceName::FormData:
    case InterfaceName::ProgressEvent:
    case InterfaceName::XMLHttpRequest:
    case InterfaceName::XMLHttpRequestEventTarget:
    case InterfaceName::XMLHttpRequestUpload:
    case InterfaceName::XPathEvaluator:
    case InterfaceName::XPathExpression:
    case InterfaceName::XPathResult:
        return true;
    default:
        return false;
    }
}
static constexpr bool is_dedicated_worker_exposed(InterfaceName name)
{
    switch (name) {
    case InterfaceName::CompressionStream:
    case InterfaceName::DecompressionStream:
    case InterfaceName::SecurityPolicyViolationEvent:
    case InterfaceName::Crypto:
    case InterfaceName::CryptoKey:
    case InterfaceName::SubtleCrypto:
    case InterfaceName::CSSImageValue:
    case InterfaceName::CSSKeywordValue:
    case InterfaceName::CSSMathClamp:
    case InterfaceName::CSSMathInvert:
    case InterfaceName::CSSMathMax:
    case InterfaceName::CSSMathMin:
    case InterfaceName::CSSMathNegate:
    case InterfaceName::CSSMathProduct:
    case InterfaceName::CSSMathSum:
    case InterfaceName::CSSMathValue:
    case InterfaceName::CSSMatrixComponent:
    case InterfaceName::CSSNumericArray:
    case InterfaceName::CSSNumericValue:
    case InterfaceName::CSSPerspective:
    case InterfaceName::CSSRotate:
    case InterfaceName::CSSScale:
    case InterfaceName::CSSSkew:
    case InterfaceName::CSSSkewX:
    case InterfaceName::CSSSkewY:
    case InterfaceName::CSSStyleValue:
    case InterfaceName::CSSTransformComponent:
    case InterfaceName::CSSTransformValue:
    case InterfaceName::CSSTranslate:
    case InterfaceName::CSSUnitValue:
    case InterfaceName::CSSUnparsedValue:
    case InterfaceName::CSSVariableReferenceValue:
    case InterfaceName::FontFace:
    case InterfaceName::FontFaceSet:
    case InterfaceName::FontFaceSetLoadEvent:
    case InterfaceName::StylePropertyMapReadOnly:
    case InterfaceName::AbortController:
    case InterfaceName::AbortSignal:
    case InterfaceName::CustomEvent:
    case InterfaceName::Event:
    case InterfaceName::EventTarget:
    case InterfaceName::URL:
    case InterfaceName::Origin:
    case InterfaceName::URLSearchParams:
    case InterfaceName::TextDecoder:
    case InterfaceName::TextDecoderStream:
    case InterfaceName::TextEncoder:
    case InterfaceName::TextEncoderStream:
    case InterfaceName::Headers:
    case InterfaceName::Request:
    case InterfaceName::Response:
    case InterfaceName::Blob:
    case InterfaceName::File:
    case InterfaceName::FileList:
    case InterfaceName::FileReader:
    case InterfaceName::FileReaderSync:
    case InterfaceName::DOMMatrix:
    case InterfaceName::DOMMatrixReadOnly:
    case InterfaceName::DOMPoint:
    case InterfaceName::DOMPointReadOnly:
    case InterfaceName::DOMQuad:
    case InterfaceName::DOMRect:
    case InterfaceName::DOMRectReadOnly:
    case InterfaceName::Performance:
    case InterfaceName::BroadcastChannel:
    case InterfaceName::CanvasGradient:
    case InterfaceName::CanvasPattern:
    case InterfaceName::CloseEvent:
    case InterfaceName::DedicatedWorkerGlobalScope:
    case InterfaceName::DOMStringList:
    case InterfaceName::ErrorEvent:
    case InterfaceName::EventSource:
    case InterfaceName::ImageBitmap:
    case InterfaceName::ImageData:
    case InterfaceName::MessageChannel:
    case InterfaceName::MessageEvent:
    case InterfaceName::MessagePort:
    case InterfaceName::OffscreenCanvas:
    case InterfaceName::OffscreenCanvasRenderingContext2D:
    case InterfaceName::Path2D:
    case InterfaceName::PromiseRejectionEvent:
    case InterfaceName::TextMetrics:
    case InterfaceName::Worker:
    case InterfaceName::WorkerGlobalScope:
    case InterfaceName::WorkerLocation:
    case InterfaceName::WorkerNavigator:
    case InterfaceName::IDBCursor:
    case InterfaceName::IDBCursorWithValue:
    case InterfaceName::IDBDatabase:
    case InterfaceName::IDBFactory:
    case InterfaceName::IDBIndex:
    case InterfaceName::IDBKeyRange:
    case InterfaceName::IDBObjectStore:
    case InterfaceName::IDBOpenDBRequest:
    case InterfaceName::IDBRecord:
    case InterfaceName::IDBRequest:
    case InterfaceName::IDBTransaction:
    case InterfaceName::IDBVersionChangeEvent:
    case InterfaceName::MediaCapabilities:
    case InterfaceName::BufferedChangeEvent:
    case InterfaceName::ManagedMediaSource:
    case InterfaceName::ManagedSourceBuffer:
    case InterfaceName::MediaSource:
    case InterfaceName::MediaSourceHandle:
    case InterfaceName::SourceBuffer:
    case InterfaceName::SourceBufferList:
    case InterfaceName::Notification:
    case InterfaceName::PerformanceEntry:
    case InterfaceName::PerformanceObserver:
    case InterfaceName::PerformanceObserverEntryList:
    case InterfaceName::Permissions:
    case InterfaceName::PermissionStatus:
    case InterfaceName::PerformanceResourceTiming:
    case InterfaceName::Serial:
    case InterfaceName::SerialPort:
    case InterfaceName::Cache:
    case InterfaceName::CacheStorage:
    case InterfaceName::ServiceWorker:
    case InterfaceName::ServiceWorkerContainer:
    case InterfaceName::ServiceWorkerRegistration:
    case InterfaceName::StorageManager:
    case InterfaceName::ByteLengthQueuingStrategy:
    case InterfaceName::CountQueuingStrategy:
    case InterfaceName::ReadableByteStreamController:
    case InterfaceName::ReadableStream:
    case InterfaceName::ReadableStreamBYOBReader:
    case InterfaceName::ReadableStreamBYOBRequest:
    case InterfaceName::ReadableStreamDefaultController:
    case InterfaceName::ReadableStreamDefaultReader:
    case InterfaceName::TransformStream:
    case InterfaceName::TransformStreamDefaultController:
    case InterfaceName::WritableStream:
    case InterfaceName::WritableStreamDefaultController:
    case InterfaceName::WritableStreamDefaultWriter:
    case InterfaceName::TrustedHTML:
    case InterfaceName::TrustedScript:
    case InterfaceName::TrustedScriptURL:
    case InterfaceName::TrustedTypePolicy:
    case InterfaceName::TrustedTypePolicyFactory:
    case InterfaceName::URLPattern:
    case InterfaceName::PerformanceMark:
    case InterfaceName::PerformanceMeasure:
    case InterfaceName::Global:
    case InterfaceName::Instance:
    case InterfaceName::Memory:
    case InterfaceName::Module:
    case InterfaceName::Table:
    case InterfaceName::WebAssembly:
    case InterfaceName::ANGLEInstancedArrays:
    case InterfaceName::EXTBlendMinMax:
    case InterfaceName::EXTColorBufferFloat:
    case InterfaceName::EXTRenderSnorm:
    case InterfaceName::EXTTextureFilterAnisotropic:
    case InterfaceName::EXTTextureNorm16:
    case InterfaceName::OESElementIndexUint:
    case InterfaceName::OESStandardDerivatives:
    case InterfaceName::OESVertexArrayObject:
    case InterfaceName::WebGLCompressedTextureS3tc:
    case InterfaceName::WebGLCompressedTextureS3tcSrgb:
    case InterfaceName::WebGLDebugRendererInfo:
    case InterfaceName::WebGLDrawBuffers:
    case InterfaceName::WebGLVertexArrayObjectOES:
    case InterfaceName::WebGL2RenderingContext:
    case InterfaceName::WebGLActiveInfo:
    case InterfaceName::WebGLBuffer:
    case InterfaceName::WebGLContextEvent:
    case InterfaceName::WebGLFramebuffer:
    case InterfaceName::WebGLObject:
    case InterfaceName::WebGLProgram:
    case InterfaceName::WebGLQuery:
    case InterfaceName::WebGLRenderbuffer:
    case InterfaceName::WebGLRenderingContext:
    case InterfaceName::WebGLSampler:
    case InterfaceName::WebGLShader:
    case InterfaceName::WebGLShaderPrecisionFormat:
    case InterfaceName::WebGLSync:
    case InterfaceName::WebGLTexture:
    case InterfaceName::WebGLTransformFeedback:
    case InterfaceName::WebGLUniformLocation:
    case InterfaceName::WebGLVertexArrayObject:
    case InterfaceName::DOMException:
    case InterfaceName::QuotaExceededError:
    case InterfaceName::WebSocket:
    case InterfaceName::FormData:
    case InterfaceName::ProgressEvent:
    case InterfaceName::XMLHttpRequest:
    case InterfaceName::XMLHttpRequestEventTarget:
    case InterfaceName::XMLHttpRequestUpload:
        return true;
    default:
        return false;
    }
}
static constexpr bool is_shared_worker_exposed(InterfaceName name)
{
    switch (name) {
    case InterfaceName::CompressionStream:
    case InterfaceName::DecompressionStream:
    case InterfaceName::SecurityPolicyViolationEvent:
    case InterfaceName::Crypto:
    case InterfaceName::CryptoKey:
    case InterfaceName::SubtleCrypto:
    case InterfaceName::CSSImageValue:
    case InterfaceName::CSSKeywordValue:
    case InterfaceName::CSSMathClamp:
    case InterfaceName::CSSMathInvert:
    case InterfaceName::CSSMathMax:
    case InterfaceName::CSSMathMin:
    case InterfaceName::CSSMathNegate:
    case InterfaceName::CSSMathProduct:
    case InterfaceName::CSSMathSum:
    case InterfaceName::CSSMathValue:
    case InterfaceName::CSSMatrixComponent:
    case InterfaceName::CSSNumericArray:
    case InterfaceName::CSSNumericValue:
    case InterfaceName::CSSPerspective:
    case InterfaceName::CSSRotate:
    case InterfaceName::CSSScale:
    case InterfaceName::CSSSkew:
    case InterfaceName::CSSSkewX:
    case InterfaceName::CSSSkewY:
    case InterfaceName::CSSStyleValue:
    case InterfaceName::CSSTransformComponent:
    case InterfaceName::CSSTransformValue:
    case InterfaceName::CSSTranslate:
    case InterfaceName::CSSUnitValue:
    case InterfaceName::CSSUnparsedValue:
    case InterfaceName::CSSVariableReferenceValue:
    case InterfaceName::FontFace:
    case InterfaceName::FontFaceSet:
    case InterfaceName::FontFaceSetLoadEvent:
    case InterfaceName::StylePropertyMapReadOnly:
    case InterfaceName::AbortController:
    case InterfaceName::AbortSignal:
    case InterfaceName::CustomEvent:
    case InterfaceName::Event:
    case InterfaceName::EventTarget:
    case InterfaceName::URL:
    case InterfaceName::Origin:
    case InterfaceName::URLSearchParams:
    case InterfaceName::TextDecoder:
    case InterfaceName::TextDecoderStream:
    case InterfaceName::TextEncoder:
    case InterfaceName::TextEncoderStream:
    case InterfaceName::Headers:
    case InterfaceName::Request:
    case InterfaceName::Response:
    case InterfaceName::Blob:
    case InterfaceName::File:
    case InterfaceName::FileList:
    case InterfaceName::FileReader:
    case InterfaceName::FileReaderSync:
    case InterfaceName::DOMMatrix:
    case InterfaceName::DOMMatrixReadOnly:
    case InterfaceName::DOMPoint:
    case InterfaceName::DOMPointReadOnly:
    case InterfaceName::DOMQuad:
    case InterfaceName::DOMRect:
    case InterfaceName::DOMRectReadOnly:
    case InterfaceName::Performance:
    case InterfaceName::BroadcastChannel:
    case InterfaceName::CanvasGradient:
    case InterfaceName::CanvasPattern:
    case InterfaceName::CloseEvent:
    case InterfaceName::DOMStringList:
    case InterfaceName::ErrorEvent:
    case InterfaceName::EventSource:
    case InterfaceName::ImageBitmap:
    case InterfaceName::ImageData:
    case InterfaceName::MessageChannel:
    case InterfaceName::MessageEvent:
    case InterfaceName::MessagePort:
    case InterfaceName::OffscreenCanvas:
    case InterfaceName::OffscreenCanvasRenderingContext2D:
    case InterfaceName::Path2D:
    case InterfaceName::PromiseRejectionEvent:
    case InterfaceName::SharedWorkerGlobalScope:
    case InterfaceName::TextMetrics:
    case InterfaceName::Worker:
    case InterfaceName::WorkerGlobalScope:
    case InterfaceName::WorkerLocation:
    case InterfaceName::WorkerNavigator:
    case InterfaceName::IDBCursor:
    case InterfaceName::IDBCursorWithValue:
    case InterfaceName::IDBDatabase:
    case InterfaceName::IDBFactory:
    case InterfaceName::IDBIndex:
    case InterfaceName::IDBKeyRange:
    case InterfaceName::IDBObjectStore:
    case InterfaceName::IDBOpenDBRequest:
    case InterfaceName::IDBRecord:
    case InterfaceName::IDBRequest:
    case InterfaceName::IDBTransaction:
    case InterfaceName::IDBVersionChangeEvent:
    case InterfaceName::MediaCapabilities:
    case InterfaceName::Notification:
    case InterfaceName::PerformanceEntry:
    case InterfaceName::PerformanceObserver:
    case InterfaceName::PerformanceObserverEntryList:
    case InterfaceName::Permissions:
    case InterfaceName::PermissionStatus:
    case InterfaceName::PerformanceResourceTiming:
    case InterfaceName::Cache:
    case InterfaceName::CacheStorage:
    case InterfaceName::ServiceWorker:
    case InterfaceName::ServiceWorkerContainer:
    case InterfaceName::ServiceWorkerRegistration:
    case InterfaceName::StorageManager:
    case InterfaceName::ByteLengthQueuingStrategy:
    case InterfaceName::CountQueuingStrategy:
    case InterfaceName::ReadableByteStreamController:
    case InterfaceName::ReadableStream:
    case InterfaceName::ReadableStreamBYOBReader:
    case InterfaceName::ReadableStreamBYOBRequest:
    case InterfaceName::ReadableStreamDefaultController:
    case InterfaceName::ReadableStreamDefaultReader:
    case InterfaceName::TransformStream:
    case InterfaceName::TransformStreamDefaultController:
    case InterfaceName::WritableStream:
    case InterfaceName::WritableStreamDefaultController:
    case InterfaceName::WritableStreamDefaultWriter:
    case InterfaceName::TrustedHTML:
    case InterfaceName::TrustedScript:
    case InterfaceName::TrustedScriptURL:
    case InterfaceName::TrustedTypePolicy:
    case InterfaceName::TrustedTypePolicyFactory:
    case InterfaceName::URLPattern:
    case InterfaceName::PerformanceMark:
    case InterfaceName::PerformanceMeasure:
    case InterfaceName::Global:
    case InterfaceName::Instance:
    case InterfaceName::Memory:
    case InterfaceName::Module:
    case InterfaceName::Table:
    case InterfaceName::WebAssembly:
    case InterfaceName::ANGLEInstancedArrays:
    case InterfaceName::EXTBlendMinMax:
    case InterfaceName::EXTColorBufferFloat:
    case InterfaceName::EXTRenderSnorm:
    case InterfaceName::EXTTextureFilterAnisotropic:
    case InterfaceName::EXTTextureNorm16:
    case InterfaceName::OESElementIndexUint:
    case InterfaceName::OESStandardDerivatives:
    case InterfaceName::OESVertexArrayObject:
    case InterfaceName::WebGLCompressedTextureS3tc:
    case InterfaceName::WebGLCompressedTextureS3tcSrgb:
    case InterfaceName::WebGLDebugRendererInfo:
    case InterfaceName::WebGLDrawBuffers:
    case InterfaceName::WebGLVertexArrayObjectOES:
    case InterfaceName::WebGL2RenderingContext:
    case InterfaceName::WebGLActiveInfo:
    case InterfaceName::WebGLBuffer:
    case InterfaceName::WebGLContextEvent:
    case InterfaceName::WebGLFramebuffer:
    case InterfaceName::WebGLObject:
    case InterfaceName::WebGLProgram:
    case InterfaceName::WebGLQuery:
    case InterfaceName::WebGLRenderbuffer:
    case InterfaceName::WebGLRenderingContext:
    case InterfaceName::WebGLSampler:
    case InterfaceName::WebGLShader:
    case InterfaceName::WebGLShaderPrecisionFormat:
    case InterfaceName::WebGLSync:
    case InterfaceName::WebGLTexture:
    case InterfaceName::WebGLTransformFeedback:
    case InterfaceName::WebGLUniformLocation:
    case InterfaceName::WebGLVertexArrayObject:
    case InterfaceName::DOMException:
    case InterfaceName::QuotaExceededError:
    case InterfaceName::WebSocket:
    case InterfaceName::FormData:
    case InterfaceName::ProgressEvent:
    case InterfaceName::XMLHttpRequest:
    case InterfaceName::XMLHttpRequestEventTarget:
    case InterfaceName::XMLHttpRequestUpload:
        return true;
    default:
        return false;
    }
}

// An interface, callback interface, namespace, or member construct is exposed in a given realm realm if the following steps return true:
bool is_exposed(InterfaceName name, JS::Realm& realm)
{
    auto const& global_object = realm.global_object();

    // 1. If construct’s exposure set is not *, and realm.[[GlobalObject]] does not implement an interface that is in construct’s exposure set, then return false.
    if (is<HTML::Window>(global_object)) {
       if (!is_window_exposed(name))
           return false;
    } else if (is<HTML::DedicatedWorkerGlobalScope>(global_object)) {
       if (!is_dedicated_worker_exposed(name))
           return false;
    } else if (is<HTML::SharedWorkerGlobalScope>(global_object)) {
        if (!is_shared_worker_exposed(name))
            return false;
    } else {
        TODO(); // FIXME: ServiceWorkerGlobalScope and WorkletGlobalScope.
    }

    // 2. If realm’s settings object is not a secure context, and construct is conditionally exposed on
    //    [SecureContext], then return false.
    if (is_secure_context_interface(name) && HTML::is_non_secure_context(principal_host_defined_environment_settings_object(realm)))
        return false;

    // AD-HOC: Do not expose experimental interfaces unless instructed to do so.
    if (!HTML::UniversalGlobalScopeMixin::expose_experimental_interfaces() && is_experimental_interface(name))
        return false;

    // FIXME: 3. If realm’s settings object’s cross-origin isolated capability is false, and construct is
    //           conditionally exposed on [CrossOriginIsolated], then return false.

    // 4. Return true.
    return true;
}

template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnimationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Animation"sv,
        .namespaced_name = "Animation"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &AnimationConstructor::initialize,
        .initialize_prototype = &AnimationPrototype::initialize,
        .define_unforgeable_attributes = &AnimationPrototype::define_unforgeable_attributes,
        .construct = &AnimationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnimationEffectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AnimationEffect"sv,
        .namespaced_name = "AnimationEffect"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AnimationEffectConstructor::initialize,
        .initialize_prototype = &AnimationEffectPrototype::initialize,
        .define_unforgeable_attributes = &AnimationEffectPrototype::define_unforgeable_attributes,
        .construct = &AnimationEffectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnimationPlaybackEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AnimationPlaybackEvent"sv,
        .namespaced_name = "AnimationPlaybackEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &AnimationPlaybackEventConstructor::initialize,
        .initialize_prototype = &AnimationPlaybackEventPrototype::initialize,
        .define_unforgeable_attributes = &AnimationPlaybackEventPrototype::define_unforgeable_attributes,
        .construct = &AnimationPlaybackEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnimationTimelinePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AnimationTimeline"sv,
        .namespaced_name = "AnimationTimeline"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AnimationTimelineConstructor::initialize,
        .initialize_prototype = &AnimationTimelinePrototype::initialize,
        .define_unforgeable_attributes = &AnimationTimelinePrototype::define_unforgeable_attributes,
        .construct = &AnimationTimelineConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DocumentTimelinePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DocumentTimeline"sv,
        .namespaced_name = "DocumentTimeline"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .initialize_constructor = &DocumentTimelineConstructor::initialize,
        .initialize_prototype = &DocumentTimelinePrototype::initialize,
        .define_unforgeable_attributes = &DocumentTimelinePrototype::define_unforgeable_attributes,
        .construct = &DocumentTimelineConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<KeyframeEffectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "KeyframeEffect"sv,
        .namespaced_name = "KeyframeEffect"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationEffectPrototype>(realm, "AnimationEffect"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationEffectPrototype>(realm, "AnimationEffect"_fly_string); },
        .initialize_constructor = &KeyframeEffectConstructor::initialize,
        .initialize_prototype = &KeyframeEffectPrototype::initialize,
        .define_unforgeable_attributes = &KeyframeEffectPrototype::define_unforgeable_attributes,
        .construct = &KeyframeEffectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ScrollTimelinePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ScrollTimeline"sv,
        .namespaced_name = "ScrollTimeline"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .initialize_constructor = &ScrollTimelineConstructor::initialize,
        .initialize_prototype = &ScrollTimelinePrototype::initialize,
        .define_unforgeable_attributes = &ScrollTimelinePrototype::define_unforgeable_attributes,
        .construct = &ScrollTimelineConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ClipboardPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Clipboard"sv,
        .namespaced_name = "Clipboard"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &ClipboardConstructor::initialize,
        .initialize_prototype = &ClipboardPrototype::initialize,
        .define_unforgeable_attributes = &ClipboardPrototype::define_unforgeable_attributes,
        .construct = &ClipboardConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ClipboardEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ClipboardEvent"sv,
        .namespaced_name = "ClipboardEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &ClipboardEventConstructor::initialize,
        .initialize_prototype = &ClipboardEventPrototype::initialize,
        .define_unforgeable_attributes = &ClipboardEventPrototype::define_unforgeable_attributes,
        .construct = &ClipboardEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ClipboardItemPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ClipboardItem"sv,
        .namespaced_name = "ClipboardItem"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ClipboardItemConstructor::initialize,
        .initialize_prototype = &ClipboardItemPrototype::initialize,
        .define_unforgeable_attributes = &ClipboardItemPrototype::define_unforgeable_attributes,
        .construct = &ClipboardItemConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CompressionStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CompressionStream"sv,
        .namespaced_name = "CompressionStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CompressionStreamConstructor::initialize,
        .initialize_prototype = &CompressionStreamPrototype::initialize,
        .define_unforgeable_attributes = &CompressionStreamPrototype::define_unforgeable_attributes,
        .construct = &CompressionStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DecompressionStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DecompressionStream"sv,
        .namespaced_name = "DecompressionStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DecompressionStreamConstructor::initialize,
        .initialize_prototype = &DecompressionStreamPrototype::initialize,
        .define_unforgeable_attributes = &DecompressionStreamPrototype::define_unforgeable_attributes,
        .construct = &DecompressionStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SecurityPolicyViolationEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SecurityPolicyViolationEvent"sv,
        .namespaced_name = "SecurityPolicyViolationEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &SecurityPolicyViolationEventConstructor::initialize,
        .initialize_prototype = &SecurityPolicyViolationEventPrototype::initialize,
        .define_unforgeable_attributes = &SecurityPolicyViolationEventPrototype::define_unforgeable_attributes,
        .construct = &SecurityPolicyViolationEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CookieChangeEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CookieChangeEvent"sv,
        .namespaced_name = "CookieChangeEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &CookieChangeEventConstructor::initialize,
        .initialize_prototype = &CookieChangeEventPrototype::initialize,
        .define_unforgeable_attributes = &CookieChangeEventPrototype::define_unforgeable_attributes,
        .construct = &CookieChangeEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CookieStorePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CookieStore"sv,
        .namespaced_name = "CookieStore"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &CookieStoreConstructor::initialize,
        .initialize_prototype = &CookieStorePrototype::initialize,
        .define_unforgeable_attributes = &CookieStorePrototype::define_unforgeable_attributes,
        .construct = &CookieStoreConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CredentialPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Credential"sv,
        .namespaced_name = "Credential"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CredentialConstructor::initialize,
        .initialize_prototype = &CredentialPrototype::initialize,
        .define_unforgeable_attributes = &CredentialPrototype::define_unforgeable_attributes,
        .construct = &CredentialConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CredentialsContainerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CredentialsContainer"sv,
        .namespaced_name = "CredentialsContainer"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CredentialsContainerConstructor::initialize,
        .initialize_prototype = &CredentialsContainerPrototype::initialize,
        .define_unforgeable_attributes = &CredentialsContainerPrototype::define_unforgeable_attributes,
        .construct = &CredentialsContainerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FederatedCredentialPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FederatedCredential"sv,
        .namespaced_name = "FederatedCredential"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CredentialPrototype>(realm, "Credential"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CredentialPrototype>(realm, "Credential"_fly_string); },
        .initialize_constructor = &FederatedCredentialConstructor::initialize,
        .initialize_prototype = &FederatedCredentialPrototype::initialize,
        .define_unforgeable_attributes = &FederatedCredentialPrototype::define_unforgeable_attributes,
        .construct = &FederatedCredentialConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PasswordCredentialPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PasswordCredential"sv,
        .namespaced_name = "PasswordCredential"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CredentialPrototype>(realm, "Credential"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CredentialPrototype>(realm, "Credential"_fly_string); },
        .initialize_constructor = &PasswordCredentialConstructor::initialize,
        .initialize_prototype = &PasswordCredentialPrototype::initialize,
        .define_unforgeable_attributes = &PasswordCredentialPrototype::define_unforgeable_attributes,
        .construct = &PasswordCredentialConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CryptoPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Crypto"sv,
        .namespaced_name = "Crypto"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CryptoConstructor::initialize,
        .initialize_prototype = &CryptoPrototype::initialize,
        .define_unforgeable_attributes = &CryptoPrototype::define_unforgeable_attributes,
        .construct = &CryptoConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CryptoKeyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CryptoKey"sv,
        .namespaced_name = "CryptoKey"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CryptoKeyConstructor::initialize,
        .initialize_prototype = &CryptoKeyPrototype::initialize,
        .define_unforgeable_attributes = &CryptoKeyPrototype::define_unforgeable_attributes,
        .construct = &CryptoKeyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SubtleCryptoPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SubtleCrypto"sv,
        .namespaced_name = "SubtleCrypto"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SubtleCryptoConstructor::initialize,
        .initialize_prototype = &SubtleCryptoPrototype::initialize,
        .define_unforgeable_attributes = &SubtleCryptoPrototype::define_unforgeable_attributes,
        .construct = &SubtleCryptoConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnimationEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AnimationEvent"sv,
        .namespaced_name = "AnimationEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &AnimationEventConstructor::initialize,
        .initialize_prototype = &AnimationEventPrototype::initialize,
        .define_unforgeable_attributes = &AnimationEventPrototype::define_unforgeable_attributes,
        .construct = &AnimationEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
void Intrinsics::create_web_namespace<CSSNamespace>(JS::Realm& realm)
{
    auto namespace_object = realm.create<CSSNamespace>(realm);
    m_namespaces.set("CSS"_fly_string, namespace_object);

    [[maybe_unused]] static constexpr u8 attr = JS::Attribute::Writable | JS::Attribute::Configurable;
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSAnimationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSAnimation"sv,
        .namespaced_name = "CSSAnimation"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationPrototype>(realm, "Animation"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationPrototype>(realm, "Animation"_fly_string); },
        .initialize_constructor = &CSSAnimationConstructor::initialize,
        .initialize_prototype = &CSSAnimationPrototype::initialize,
        .define_unforgeable_attributes = &CSSAnimationPrototype::define_unforgeable_attributes,
        .construct = &CSSAnimationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSConditionRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSConditionRule"sv,
        .namespaced_name = "CSSConditionRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .initialize_constructor = &CSSConditionRuleConstructor::initialize,
        .initialize_prototype = &CSSConditionRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSConditionRulePrototype::define_unforgeable_attributes,
        .construct = &CSSConditionRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSContainerRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSContainerRule"sv,
        .namespaced_name = "CSSContainerRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .initialize_constructor = &CSSContainerRuleConstructor::initialize,
        .initialize_prototype = &CSSContainerRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSContainerRulePrototype::define_unforgeable_attributes,
        .construct = &CSSContainerRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSCounterStyleRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSCounterStyleRule"sv,
        .namespaced_name = "CSSCounterStyleRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSCounterStyleRuleConstructor::initialize,
        .initialize_prototype = &CSSCounterStyleRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSCounterStyleRulePrototype::define_unforgeable_attributes,
        .construct = &CSSCounterStyleRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFontFaceDescriptorsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFontFaceDescriptors"sv,
        .namespaced_name = "CSSFontFaceDescriptors"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .initialize_constructor = &CSSFontFaceDescriptorsConstructor::initialize,
        .initialize_prototype = &CSSFontFaceDescriptorsPrototype::initialize,
        .define_unforgeable_attributes = &CSSFontFaceDescriptorsPrototype::define_unforgeable_attributes,
        .construct = &CSSFontFaceDescriptorsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFontFaceRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFontFaceRule"sv,
        .namespaced_name = "CSSFontFaceRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSFontFaceRuleConstructor::initialize,
        .initialize_prototype = &CSSFontFaceRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSFontFaceRulePrototype::define_unforgeable_attributes,
        .construct = &CSSFontFaceRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFontFeatureValuesMapPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFontFeatureValuesMap"sv,
        .namespaced_name = "CSSFontFeatureValuesMap"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSFontFeatureValuesMapConstructor::initialize,
        .construct = &CSSFontFeatureValuesMapConstructor::construct,
    };

    auto prototype = realm.create<CSSFontFeatureValuesMapPrototype>(realm);
    m_prototypes.set("CSSFontFeatureValuesMap"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFontFeatureValuesRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFontFeatureValuesRule"sv,
        .namespaced_name = "CSSFontFeatureValuesRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSFontFeatureValuesRuleConstructor::initialize,
        .initialize_prototype = &CSSFontFeatureValuesRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSFontFeatureValuesRulePrototype::define_unforgeable_attributes,
        .construct = &CSSFontFeatureValuesRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFunctionDeclarationsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFunctionDeclarations"sv,
        .namespaced_name = "CSSFunctionDeclarations"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSFunctionDeclarationsConstructor::initialize,
        .initialize_prototype = &CSSFunctionDeclarationsPrototype::initialize,
        .define_unforgeable_attributes = &CSSFunctionDeclarationsPrototype::define_unforgeable_attributes,
        .construct = &CSSFunctionDeclarationsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFunctionDescriptorsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFunctionDescriptors"sv,
        .namespaced_name = "CSSFunctionDescriptors"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .initialize_constructor = &CSSFunctionDescriptorsConstructor::initialize,
        .initialize_prototype = &CSSFunctionDescriptorsPrototype::initialize,
        .define_unforgeable_attributes = &CSSFunctionDescriptorsPrototype::define_unforgeable_attributes,
        .construct = &CSSFunctionDescriptorsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSFunctionRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSFunctionRule"sv,
        .namespaced_name = "CSSFunctionRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .initialize_constructor = &CSSFunctionRuleConstructor::initialize,
        .initialize_prototype = &CSSFunctionRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSFunctionRulePrototype::define_unforgeable_attributes,
        .construct = &CSSFunctionRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSGroupingRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSGroupingRule"sv,
        .namespaced_name = "CSSGroupingRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSGroupingRuleConstructor::initialize,
        .initialize_prototype = &CSSGroupingRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSGroupingRulePrototype::define_unforgeable_attributes,
        .construct = &CSSGroupingRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSImageValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSImageValue"sv,
        .namespaced_name = "CSSImageValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .initialize_constructor = &CSSImageValueConstructor::initialize,
        .initialize_prototype = &CSSImageValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSImageValuePrototype::define_unforgeable_attributes,
        .construct = &CSSImageValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSImportRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSImportRule"sv,
        .namespaced_name = "CSSImportRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSImportRuleConstructor::initialize,
        .initialize_prototype = &CSSImportRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSImportRulePrototype::define_unforgeable_attributes,
        .construct = &CSSImportRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSKeyframeRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSKeyframeRule"sv,
        .namespaced_name = "CSSKeyframeRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSKeyframeRuleConstructor::initialize,
        .initialize_prototype = &CSSKeyframeRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSKeyframeRulePrototype::define_unforgeable_attributes,
        .construct = &CSSKeyframeRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSKeyframesRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSKeyframesRule"sv,
        .namespaced_name = "CSSKeyframesRule"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSKeyframesRuleConstructor::initialize,
        .construct = &CSSKeyframesRuleConstructor::construct,
    };

    auto prototype = realm.create<CSSKeyframesRulePrototype>(realm);
    m_prototypes.set("CSSKeyframesRule"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSKeywordValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSKeywordValue"sv,
        .namespaced_name = "CSSKeywordValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .initialize_constructor = &CSSKeywordValueConstructor::initialize,
        .initialize_prototype = &CSSKeywordValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSKeywordValuePrototype::define_unforgeable_attributes,
        .construct = &CSSKeywordValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSLayerBlockRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSLayerBlockRule"sv,
        .namespaced_name = "CSSLayerBlockRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .initialize_constructor = &CSSLayerBlockRuleConstructor::initialize,
        .initialize_prototype = &CSSLayerBlockRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSLayerBlockRulePrototype::define_unforgeable_attributes,
        .construct = &CSSLayerBlockRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSLayerStatementRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSLayerStatementRule"sv,
        .namespaced_name = "CSSLayerStatementRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSLayerStatementRuleConstructor::initialize,
        .initialize_prototype = &CSSLayerStatementRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSLayerStatementRulePrototype::define_unforgeable_attributes,
        .construct = &CSSLayerStatementRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMarginRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMarginRule"sv,
        .namespaced_name = "CSSMarginRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSMarginRuleConstructor::initialize,
        .initialize_prototype = &CSSMarginRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSMarginRulePrototype::define_unforgeable_attributes,
        .construct = &CSSMarginRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathClampPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathClamp"sv,
        .namespaced_name = "CSSMathClamp"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathClampConstructor::initialize,
        .initialize_prototype = &CSSMathClampPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathClampPrototype::define_unforgeable_attributes,
        .construct = &CSSMathClampConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathInvertPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathInvert"sv,
        .namespaced_name = "CSSMathInvert"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathInvertConstructor::initialize,
        .initialize_prototype = &CSSMathInvertPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathInvertPrototype::define_unforgeable_attributes,
        .construct = &CSSMathInvertConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathMaxPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathMax"sv,
        .namespaced_name = "CSSMathMax"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathMaxConstructor::initialize,
        .initialize_prototype = &CSSMathMaxPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathMaxPrototype::define_unforgeable_attributes,
        .construct = &CSSMathMaxConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathMinPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathMin"sv,
        .namespaced_name = "CSSMathMin"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathMinConstructor::initialize,
        .initialize_prototype = &CSSMathMinPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathMinPrototype::define_unforgeable_attributes,
        .construct = &CSSMathMinConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathNegatePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathNegate"sv,
        .namespaced_name = "CSSMathNegate"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathNegateConstructor::initialize,
        .initialize_prototype = &CSSMathNegatePrototype::initialize,
        .define_unforgeable_attributes = &CSSMathNegatePrototype::define_unforgeable_attributes,
        .construct = &CSSMathNegateConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathProductPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathProduct"sv,
        .namespaced_name = "CSSMathProduct"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathProductConstructor::initialize,
        .initialize_prototype = &CSSMathProductPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathProductPrototype::define_unforgeable_attributes,
        .construct = &CSSMathProductConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathSumPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathSum"sv,
        .namespaced_name = "CSSMathSum"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSMathValuePrototype>(realm, "CSSMathValue"_fly_string); },
        .initialize_constructor = &CSSMathSumConstructor::initialize,
        .initialize_prototype = &CSSMathSumPrototype::initialize,
        .define_unforgeable_attributes = &CSSMathSumPrototype::define_unforgeable_attributes,
        .construct = &CSSMathSumConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMathValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMathValue"sv,
        .namespaced_name = "CSSMathValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSNumericValuePrototype>(realm, "CSSNumericValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSNumericValuePrototype>(realm, "CSSNumericValue"_fly_string); },
        .initialize_constructor = &CSSMathValueConstructor::initialize,
        .initialize_prototype = &CSSMathValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSMathValuePrototype::define_unforgeable_attributes,
        .construct = &CSSMathValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMatrixComponentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMatrixComponent"sv,
        .namespaced_name = "CSSMatrixComponent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSMatrixComponentConstructor::initialize,
        .initialize_prototype = &CSSMatrixComponentPrototype::initialize,
        .define_unforgeable_attributes = &CSSMatrixComponentPrototype::define_unforgeable_attributes,
        .construct = &CSSMatrixComponentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSMediaRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSMediaRule"sv,
        .namespaced_name = "CSSMediaRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .initialize_constructor = &CSSMediaRuleConstructor::initialize,
        .initialize_prototype = &CSSMediaRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSMediaRulePrototype::define_unforgeable_attributes,
        .construct = &CSSMediaRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSNamespaceRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSNamespaceRule"sv,
        .namespaced_name = "CSSNamespaceRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSNamespaceRuleConstructor::initialize,
        .initialize_prototype = &CSSNamespaceRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSNamespaceRulePrototype::define_unforgeable_attributes,
        .construct = &CSSNamespaceRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSNestedDeclarationsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSNestedDeclarations"sv,
        .namespaced_name = "CSSNestedDeclarations"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSNestedDeclarationsConstructor::initialize,
        .initialize_prototype = &CSSNestedDeclarationsPrototype::initialize,
        .define_unforgeable_attributes = &CSSNestedDeclarationsPrototype::define_unforgeable_attributes,
        .construct = &CSSNestedDeclarationsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSNumericArrayPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSNumericArray"sv,
        .namespaced_name = "CSSNumericArray"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSNumericArrayConstructor::initialize,
        .construct = &CSSNumericArrayConstructor::construct,
    };

    auto prototype = realm.create<CSSNumericArrayPrototype>(realm);
    m_prototypes.set("CSSNumericArray"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSNumericValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSNumericValue"sv,
        .namespaced_name = "CSSNumericValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .initialize_constructor = &CSSNumericValueConstructor::initialize,
        .initialize_prototype = &CSSNumericValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSNumericValuePrototype::define_unforgeable_attributes,
        .construct = &CSSNumericValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSPageDescriptorsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSPageDescriptors"sv,
        .namespaced_name = "CSSPageDescriptors"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .initialize_constructor = &CSSPageDescriptorsConstructor::initialize,
        .initialize_prototype = &CSSPageDescriptorsPrototype::initialize,
        .define_unforgeable_attributes = &CSSPageDescriptorsPrototype::define_unforgeable_attributes,
        .construct = &CSSPageDescriptorsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSPageRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSPageRule"sv,
        .namespaced_name = "CSSPageRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .initialize_constructor = &CSSPageRuleConstructor::initialize,
        .initialize_prototype = &CSSPageRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSPageRulePrototype::define_unforgeable_attributes,
        .construct = &CSSPageRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSPerspectivePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSPerspective"sv,
        .namespaced_name = "CSSPerspective"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSPerspectiveConstructor::initialize,
        .initialize_prototype = &CSSPerspectivePrototype::initialize,
        .define_unforgeable_attributes = &CSSPerspectivePrototype::define_unforgeable_attributes,
        .construct = &CSSPerspectiveConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSPropertyRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSPropertyRule"sv,
        .namespaced_name = "CSSPropertyRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSRulePrototype>(realm, "CSSRule"_fly_string); },
        .initialize_constructor = &CSSPropertyRuleConstructor::initialize,
        .initialize_prototype = &CSSPropertyRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSPropertyRulePrototype::define_unforgeable_attributes,
        .construct = &CSSPropertyRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSRotatePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSRotate"sv,
        .namespaced_name = "CSSRotate"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSRotateConstructor::initialize,
        .initialize_prototype = &CSSRotatePrototype::initialize,
        .define_unforgeable_attributes = &CSSRotatePrototype::define_unforgeable_attributes,
        .construct = &CSSRotateConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSRule"sv,
        .namespaced_name = "CSSRule"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSRuleConstructor::initialize,
        .initialize_prototype = &CSSRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSRulePrototype::define_unforgeable_attributes,
        .construct = &CSSRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSRuleListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSRuleList"sv,
        .namespaced_name = "CSSRuleList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSRuleListConstructor::initialize,
        .construct = &CSSRuleListConstructor::construct,
    };

    auto prototype = realm.create<CSSRuleListPrototype>(realm);
    m_prototypes.set("CSSRuleList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSScalePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSScale"sv,
        .namespaced_name = "CSSScale"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSScaleConstructor::initialize,
        .initialize_prototype = &CSSScalePrototype::initialize,
        .define_unforgeable_attributes = &CSSScalePrototype::define_unforgeable_attributes,
        .construct = &CSSScaleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSSkewPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSSkew"sv,
        .namespaced_name = "CSSSkew"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSSkewConstructor::initialize,
        .initialize_prototype = &CSSSkewPrototype::initialize,
        .define_unforgeable_attributes = &CSSSkewPrototype::define_unforgeable_attributes,
        .construct = &CSSSkewConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSSkewXPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSSkewX"sv,
        .namespaced_name = "CSSSkewX"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSSkewXConstructor::initialize,
        .initialize_prototype = &CSSSkewXPrototype::initialize,
        .define_unforgeable_attributes = &CSSSkewXPrototype::define_unforgeable_attributes,
        .construct = &CSSSkewXConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSSkewYPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSSkewY"sv,
        .namespaced_name = "CSSSkewY"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSSkewYConstructor::initialize,
        .initialize_prototype = &CSSSkewYPrototype::initialize,
        .define_unforgeable_attributes = &CSSSkewYPrototype::define_unforgeable_attributes,
        .construct = &CSSSkewYConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSStyleDeclarationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSStyleDeclaration"sv,
        .namespaced_name = "CSSStyleDeclaration"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSStyleDeclarationConstructor::initialize,
        .construct = &CSSStyleDeclarationConstructor::construct,
    };

    auto prototype = realm.create<CSSStyleDeclarationPrototype>(realm);
    m_prototypes.set("CSSStyleDeclaration"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSStylePropertiesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSStyleProperties"sv,
        .namespaced_name = "CSSStyleProperties"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleDeclarationPrototype>(realm, "CSSStyleDeclaration"_fly_string); },
        .initialize_constructor = &CSSStylePropertiesConstructor::initialize,
        .initialize_prototype = &CSSStylePropertiesPrototype::initialize,
        .define_unforgeable_attributes = &CSSStylePropertiesPrototype::define_unforgeable_attributes,
        .construct = &CSSStylePropertiesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSStyleRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSStyleRule"sv,
        .namespaced_name = "CSSStyleRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSGroupingRulePrototype>(realm, "CSSGroupingRule"_fly_string); },
        .initialize_constructor = &CSSStyleRuleConstructor::initialize,
        .initialize_prototype = &CSSStyleRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSStyleRulePrototype::define_unforgeable_attributes,
        .construct = &CSSStyleRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSStyleSheetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSStyleSheet"sv,
        .namespaced_name = "CSSStyleSheet"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<StyleSheetPrototype>(realm, "StyleSheet"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<StyleSheetPrototype>(realm, "StyleSheet"_fly_string); },
        .initialize_constructor = &CSSStyleSheetConstructor::initialize,
        .initialize_prototype = &CSSStyleSheetPrototype::initialize,
        .define_unforgeable_attributes = &CSSStyleSheetPrototype::define_unforgeable_attributes,
        .construct = &CSSStyleSheetConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSStyleValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSStyleValue"sv,
        .namespaced_name = "CSSStyleValue"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSStyleValueConstructor::initialize,
        .initialize_prototype = &CSSStyleValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSStyleValuePrototype::define_unforgeable_attributes,
        .construct = &CSSStyleValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSSupportsRulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSSupportsRule"sv,
        .namespaced_name = "CSSSupportsRule"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSConditionRulePrototype>(realm, "CSSConditionRule"_fly_string); },
        .initialize_constructor = &CSSSupportsRuleConstructor::initialize,
        .initialize_prototype = &CSSSupportsRulePrototype::initialize,
        .define_unforgeable_attributes = &CSSSupportsRulePrototype::define_unforgeable_attributes,
        .construct = &CSSSupportsRuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSTransformComponentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSTransformComponent"sv,
        .namespaced_name = "CSSTransformComponent"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSTransformComponentConstructor::initialize,
        .initialize_prototype = &CSSTransformComponentPrototype::initialize,
        .define_unforgeable_attributes = &CSSTransformComponentPrototype::define_unforgeable_attributes,
        .construct = &CSSTransformComponentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSTransformValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSTransformValue"sv,
        .namespaced_name = "CSSTransformValue"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .initialize_constructor = &CSSTransformValueConstructor::initialize,
        .construct = &CSSTransformValueConstructor::construct,
    };

    auto prototype = realm.create<CSSTransformValuePrototype>(realm);
    m_prototypes.set("CSSTransformValue"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSTransitionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSTransition"sv,
        .namespaced_name = "CSSTransition"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationPrototype>(realm, "Animation"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationPrototype>(realm, "Animation"_fly_string); },
        .initialize_constructor = &CSSTransitionConstructor::initialize,
        .initialize_prototype = &CSSTransitionPrototype::initialize,
        .define_unforgeable_attributes = &CSSTransitionPrototype::define_unforgeable_attributes,
        .construct = &CSSTransitionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSTranslatePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSTranslate"sv,
        .namespaced_name = "CSSTranslate"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSTransformComponentPrototype>(realm, "CSSTransformComponent"_fly_string); },
        .initialize_constructor = &CSSTranslateConstructor::initialize,
        .initialize_prototype = &CSSTranslatePrototype::initialize,
        .define_unforgeable_attributes = &CSSTranslatePrototype::define_unforgeable_attributes,
        .construct = &CSSTranslateConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSUnitValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSUnitValue"sv,
        .namespaced_name = "CSSUnitValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CSSNumericValuePrototype>(realm, "CSSNumericValue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSNumericValuePrototype>(realm, "CSSNumericValue"_fly_string); },
        .initialize_constructor = &CSSUnitValueConstructor::initialize,
        .initialize_prototype = &CSSUnitValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSUnitValuePrototype::define_unforgeable_attributes,
        .construct = &CSSUnitValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSUnparsedValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSUnparsedValue"sv,
        .namespaced_name = "CSSUnparsedValue"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CSSStyleValuePrototype>(realm, "CSSStyleValue"_fly_string); },
        .initialize_constructor = &CSSUnparsedValueConstructor::initialize,
        .construct = &CSSUnparsedValueConstructor::construct,
    };

    auto prototype = realm.create<CSSUnparsedValuePrototype>(realm);
    m_prototypes.set("CSSUnparsedValue"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CSSVariableReferenceValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CSSVariableReferenceValue"sv,
        .namespaced_name = "CSSVariableReferenceValue"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CSSVariableReferenceValueConstructor::initialize,
        .initialize_prototype = &CSSVariableReferenceValuePrototype::initialize,
        .define_unforgeable_attributes = &CSSVariableReferenceValuePrototype::define_unforgeable_attributes,
        .construct = &CSSVariableReferenceValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FontFacePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FontFace"sv,
        .namespaced_name = "FontFace"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FontFaceConstructor::initialize,
        .initialize_prototype = &FontFacePrototype::initialize,
        .define_unforgeable_attributes = &FontFacePrototype::define_unforgeable_attributes,
        .construct = &FontFaceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FontFaceSetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FontFaceSet"sv,
        .namespaced_name = "FontFaceSet"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &FontFaceSetConstructor::initialize,
        .construct = &FontFaceSetConstructor::construct,
    };

    auto prototype = realm.create<FontFaceSetPrototype>(realm);
    m_prototypes.set("FontFaceSet"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FontFaceSetLoadEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FontFaceSetLoadEvent"sv,
        .namespaced_name = "FontFaceSetLoadEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &FontFaceSetLoadEventConstructor::initialize,
        .initialize_prototype = &FontFaceSetLoadEventPrototype::initialize,
        .define_unforgeable_attributes = &FontFaceSetLoadEventPrototype::define_unforgeable_attributes,
        .construct = &FontFaceSetLoadEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaList"sv,
        .namespaced_name = "MediaList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaListConstructor::initialize,
        .construct = &MediaListConstructor::construct,
    };

    auto prototype = realm.create<MediaListPrototype>(realm);
    m_prototypes.set("MediaList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaQueryListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaQueryList"sv,
        .namespaced_name = "MediaQueryList"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MediaQueryListConstructor::initialize,
        .initialize_prototype = &MediaQueryListPrototype::initialize,
        .define_unforgeable_attributes = &MediaQueryListPrototype::define_unforgeable_attributes,
        .construct = &MediaQueryListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaQueryListEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaQueryListEvent"sv,
        .namespaced_name = "MediaQueryListEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &MediaQueryListEventConstructor::initialize,
        .initialize_prototype = &MediaQueryListEventPrototype::initialize,
        .define_unforgeable_attributes = &MediaQueryListEventPrototype::define_unforgeable_attributes,
        .construct = &MediaQueryListEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ScreenPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Screen"sv,
        .namespaced_name = "Screen"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ScreenConstructor::initialize,
        .initialize_prototype = &ScreenPrototype::initialize,
        .define_unforgeable_attributes = &ScreenPrototype::define_unforgeable_attributes,
        .construct = &ScreenConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ScreenOrientationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ScreenOrientation"sv,
        .namespaced_name = "ScreenOrientation"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &ScreenOrientationConstructor::initialize,
        .initialize_prototype = &ScreenOrientationPrototype::initialize,
        .define_unforgeable_attributes = &ScreenOrientationPrototype::define_unforgeable_attributes,
        .construct = &ScreenOrientationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StylePropertyMapPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StylePropertyMap"sv,
        .namespaced_name = "StylePropertyMap"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<StylePropertyMapReadOnlyPrototype>(realm, "StylePropertyMapReadOnly"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<StylePropertyMapReadOnlyPrototype>(realm, "StylePropertyMapReadOnly"_fly_string); },
        .initialize_constructor = &StylePropertyMapConstructor::initialize,
        .initialize_prototype = &StylePropertyMapPrototype::initialize,
        .define_unforgeable_attributes = &StylePropertyMapPrototype::define_unforgeable_attributes,
        .construct = &StylePropertyMapConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StylePropertyMapReadOnlyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StylePropertyMapReadOnly"sv,
        .namespaced_name = "StylePropertyMapReadOnly"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &StylePropertyMapReadOnlyConstructor::initialize,
        .initialize_prototype = &StylePropertyMapReadOnlyPrototype::initialize,
        .define_unforgeable_attributes = &StylePropertyMapReadOnlyPrototype::define_unforgeable_attributes,
        .construct = &StylePropertyMapReadOnlyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StyleSheetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StyleSheet"sv,
        .namespaced_name = "StyleSheet"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &StyleSheetConstructor::initialize,
        .initialize_prototype = &StyleSheetPrototype::initialize,
        .define_unforgeable_attributes = &StyleSheetPrototype::define_unforgeable_attributes,
        .construct = &StyleSheetConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StyleSheetListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StyleSheetList"sv,
        .namespaced_name = "StyleSheetList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &StyleSheetListConstructor::initialize,
        .construct = &StyleSheetListConstructor::construct,
    };

    auto prototype = realm.create<StyleSheetListPrototype>(realm);
    m_prototypes.set("StyleSheetList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TransitionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TransitionEvent"sv,
        .namespaced_name = "TransitionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &TransitionEventConstructor::initialize,
        .initialize_prototype = &TransitionEventPrototype::initialize,
        .define_unforgeable_attributes = &TransitionEventPrototype::define_unforgeable_attributes,
        .construct = &TransitionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<VisualViewportPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "VisualViewport"sv,
        .namespaced_name = "VisualViewport"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &VisualViewportConstructor::initialize,
        .initialize_prototype = &VisualViewportPrototype::initialize,
        .define_unforgeable_attributes = &VisualViewportPrototype::define_unforgeable_attributes,
        .construct = &VisualViewportConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AbortControllerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AbortController"sv,
        .namespaced_name = "AbortController"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AbortControllerConstructor::initialize,
        .initialize_prototype = &AbortControllerPrototype::initialize,
        .define_unforgeable_attributes = &AbortControllerPrototype::define_unforgeable_attributes,
        .construct = &AbortControllerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AbortSignalPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AbortSignal"sv,
        .namespaced_name = "AbortSignal"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &AbortSignalConstructor::initialize,
        .initialize_prototype = &AbortSignalPrototype::initialize,
        .define_unforgeable_attributes = &AbortSignalPrototype::define_unforgeable_attributes,
        .construct = &AbortSignalConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AbstractRangePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AbstractRange"sv,
        .namespaced_name = "AbstractRange"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AbstractRangeConstructor::initialize,
        .initialize_prototype = &AbstractRangePrototype::initialize,
        .define_unforgeable_attributes = &AbstractRangePrototype::define_unforgeable_attributes,
        .construct = &AbstractRangeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AttrPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Attr"sv,
        .namespaced_name = "Attr"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &AttrConstructor::initialize,
        .initialize_prototype = &AttrPrototype::initialize,
        .define_unforgeable_attributes = &AttrPrototype::define_unforgeable_attributes,
        .construct = &AttrConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CDATASectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CDATASection"sv,
        .namespaced_name = "CDATASection"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<TextPrototype>(realm, "Text"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<TextPrototype>(realm, "Text"_fly_string); },
        .initialize_constructor = &CDATASectionConstructor::initialize,
        .initialize_prototype = &CDATASectionPrototype::initialize,
        .define_unforgeable_attributes = &CDATASectionPrototype::define_unforgeable_attributes,
        .construct = &CDATASectionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CharacterDataPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CharacterData"sv,
        .namespaced_name = "CharacterData"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &CharacterDataConstructor::initialize,
        .initialize_prototype = &CharacterDataPrototype::initialize,
        .define_unforgeable_attributes = &CharacterDataPrototype::define_unforgeable_attributes,
        .construct = &CharacterDataConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CommentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Comment"sv,
        .namespaced_name = "Comment"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .initialize_constructor = &CommentConstructor::initialize,
        .initialize_prototype = &CommentPrototype::initialize,
        .define_unforgeable_attributes = &CommentPrototype::define_unforgeable_attributes,
        .construct = &CommentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CustomEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CustomEvent"sv,
        .namespaced_name = "CustomEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &CustomEventConstructor::initialize,
        .initialize_prototype = &CustomEventPrototype::initialize,
        .define_unforgeable_attributes = &CustomEventPrototype::define_unforgeable_attributes,
        .construct = &CustomEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DocumentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Document"sv,
        .namespaced_name = "Document"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &DocumentConstructor::initialize,
        .initialize_prototype = &DocumentPrototype::initialize,
        .define_unforgeable_attributes = &DocumentPrototype::define_unforgeable_attributes,
        .construct = &DocumentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DocumentFragmentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DocumentFragment"sv,
        .namespaced_name = "DocumentFragment"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &DocumentFragmentConstructor::initialize,
        .initialize_prototype = &DocumentFragmentPrototype::initialize,
        .define_unforgeable_attributes = &DocumentFragmentPrototype::define_unforgeable_attributes,
        .construct = &DocumentFragmentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DocumentTypePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DocumentType"sv,
        .namespaced_name = "DocumentType"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &DocumentTypeConstructor::initialize,
        .initialize_prototype = &DocumentTypePrototype::initialize,
        .define_unforgeable_attributes = &DocumentTypePrototype::define_unforgeable_attributes,
        .construct = &DocumentTypeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMImplementationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMImplementation"sv,
        .namespaced_name = "DOMImplementation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMImplementationConstructor::initialize,
        .initialize_prototype = &DOMImplementationPrototype::initialize,
        .define_unforgeable_attributes = &DOMImplementationPrototype::define_unforgeable_attributes,
        .construct = &DOMImplementationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMTokenListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMTokenList"sv,
        .namespaced_name = "DOMTokenList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMTokenListConstructor::initialize,
        .construct = &DOMTokenListConstructor::construct,
    };

    auto prototype = realm.create<DOMTokenListPrototype>(realm);
    m_prototypes.set("DOMTokenList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Element"sv,
        .namespaced_name = "Element"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodePrototype>(realm, "Node"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodePrototype>(realm, "Node"_fly_string); },
        .initialize_constructor = &ElementConstructor::initialize,
        .initialize_prototype = &ElementPrototype::initialize,
        .define_unforgeable_attributes = &ElementPrototype::define_unforgeable_attributes,
        .construct = &ElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Event"sv,
        .namespaced_name = "Event"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EventConstructor::initialize,
        .initialize_prototype = &EventPrototype::initialize,
        .define_unforgeable_attributes = &EventPrototype::define_unforgeable_attributes,
        .construct = &EventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EventTargetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EventTarget"sv,
        .namespaced_name = "EventTarget"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EventTargetConstructor::initialize,
        .initialize_prototype = &EventTargetPrototype::initialize,
        .define_unforgeable_attributes = &EventTargetPrototype::define_unforgeable_attributes,
        .construct = &EventTargetConstructor::construct,
        .has_immutable_prototype = true,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLCollectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLCollection"sv,
        .namespaced_name = "HTMLCollection"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &HTMLCollectionConstructor::initialize,
        .construct = &HTMLCollectionConstructor::construct,
    };

    auto prototype = realm.create<HTMLCollectionPrototype>(realm);
    m_prototypes.set("HTMLCollection"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MutationObserverPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MutationObserver"sv,
        .namespaced_name = "MutationObserver"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MutationObserverConstructor::initialize,
        .initialize_prototype = &MutationObserverPrototype::initialize,
        .define_unforgeable_attributes = &MutationObserverPrototype::define_unforgeable_attributes,
        .construct = &MutationObserverConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MutationRecordPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MutationRecord"sv,
        .namespaced_name = "MutationRecord"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MutationRecordConstructor::initialize,
        .initialize_prototype = &MutationRecordPrototype::initialize,
        .define_unforgeable_attributes = &MutationRecordPrototype::define_unforgeable_attributes,
        .construct = &MutationRecordConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NamedNodeMapPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NamedNodeMap"sv,
        .namespaced_name = "NamedNodeMap"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NamedNodeMapConstructor::initialize,
        .construct = &NamedNodeMapConstructor::construct,
    };

    auto prototype = realm.create<NamedNodeMapPrototype>(realm);
    m_prototypes.set("NamedNodeMap"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Node"sv,
        .namespaced_name = "Node"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &NodeConstructor::initialize,
        .initialize_prototype = &NodePrototype::initialize,
        .define_unforgeable_attributes = &NodePrototype::define_unforgeable_attributes,
        .construct = &NodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NodeFilterPrototype>(JS::Realm& realm)
{
    auto& vm = realm.vm();

    auto prototype = realm.create<NodeFilterPrototype>(realm);
    m_prototypes.set("NodeFilter"_fly_string, prototype);

    auto constructor = realm.create<NodeFilterConstructor>(realm);
    m_constructors.set("NodeFilter"_fly_string, constructor);

    prototype->define_direct_property(vm.names.constructor, constructor.ptr(), JS::Attribute::Writable | JS::Attribute::Configurable);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NodeIteratorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NodeIterator"sv,
        .namespaced_name = "NodeIterator"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NodeIteratorConstructor::initialize,
        .initialize_prototype = &NodeIteratorPrototype::initialize,
        .define_unforgeable_attributes = &NodeIteratorPrototype::define_unforgeable_attributes,
        .construct = &NodeIteratorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NodeListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NodeList"sv,
        .namespaced_name = "NodeList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NodeListConstructor::initialize,
        .construct = &NodeListConstructor::construct,
    };

    auto prototype = realm.create<NodeListPrototype>(realm);
    m_prototypes.set("NodeList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ProcessingInstructionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ProcessingInstruction"sv,
        .namespaced_name = "ProcessingInstruction"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .initialize_constructor = &ProcessingInstructionConstructor::initialize,
        .initialize_prototype = &ProcessingInstructionPrototype::initialize,
        .define_unforgeable_attributes = &ProcessingInstructionPrototype::define_unforgeable_attributes,
        .construct = &ProcessingInstructionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<RangePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Range"sv,
        .namespaced_name = "Range"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AbstractRangePrototype>(realm, "AbstractRange"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AbstractRangePrototype>(realm, "AbstractRange"_fly_string); },
        .initialize_constructor = &RangeConstructor::initialize,
        .initialize_prototype = &RangePrototype::initialize,
        .define_unforgeable_attributes = &RangePrototype::define_unforgeable_attributes,
        .construct = &RangeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ShadowRootPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ShadowRoot"sv,
        .namespaced_name = "ShadowRoot"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DocumentFragmentPrototype>(realm, "DocumentFragment"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DocumentFragmentPrototype>(realm, "DocumentFragment"_fly_string); },
        .initialize_constructor = &ShadowRootConstructor::initialize,
        .initialize_prototype = &ShadowRootPrototype::initialize,
        .define_unforgeable_attributes = &ShadowRootPrototype::define_unforgeable_attributes,
        .construct = &ShadowRootConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StaticRangePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StaticRange"sv,
        .namespaced_name = "StaticRange"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AbstractRangePrototype>(realm, "AbstractRange"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AbstractRangePrototype>(realm, "AbstractRange"_fly_string); },
        .initialize_constructor = &StaticRangeConstructor::initialize,
        .initialize_prototype = &StaticRangePrototype::initialize,
        .define_unforgeable_attributes = &StaticRangePrototype::define_unforgeable_attributes,
        .construct = &StaticRangeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Text"sv,
        .namespaced_name = "Text"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<CharacterDataPrototype>(realm, "CharacterData"_fly_string); },
        .initialize_constructor = &TextConstructor::initialize,
        .initialize_prototype = &TextPrototype::initialize,
        .define_unforgeable_attributes = &TextPrototype::define_unforgeable_attributes,
        .construct = &TextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TreeWalkerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TreeWalker"sv,
        .namespaced_name = "TreeWalker"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TreeWalkerConstructor::initialize,
        .initialize_prototype = &TreeWalkerPrototype::initialize,
        .define_unforgeable_attributes = &TreeWalkerPrototype::define_unforgeable_attributes,
        .construct = &TreeWalkerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XMLDocumentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XMLDocument"sv,
        .namespaced_name = "XMLDocument"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DocumentPrototype>(realm, "Document"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DocumentPrototype>(realm, "Document"_fly_string); },
        .initialize_constructor = &XMLDocumentConstructor::initialize,
        .initialize_prototype = &XMLDocumentPrototype::initialize,
        .define_unforgeable_attributes = &XMLDocumentPrototype::define_unforgeable_attributes,
        .construct = &XMLDocumentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMURLPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "URL"sv,
        .namespaced_name = "URL"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMURLConstructor::initialize,
        .initialize_prototype = &DOMURLPrototype::initialize,
        .define_unforgeable_attributes = &DOMURLPrototype::define_unforgeable_attributes,
        .construct = &DOMURLConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OriginPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Origin"sv,
        .namespaced_name = "Origin"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &OriginConstructor::initialize,
        .initialize_prototype = &OriginPrototype::initialize,
        .define_unforgeable_attributes = &OriginPrototype::define_unforgeable_attributes,
        .construct = &OriginConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<URLSearchParamsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "URLSearchParams"sv,
        .namespaced_name = "URLSearchParams"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &URLSearchParamsConstructor::initialize,
        .construct = &URLSearchParamsConstructor::construct,
    };

    auto prototype = realm.create<URLSearchParamsPrototype>(realm);
    m_prototypes.set("URLSearchParams"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextDecoderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextDecoder"sv,
        .namespaced_name = "TextDecoder"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextDecoderConstructor::initialize,
        .initialize_prototype = &TextDecoderPrototype::initialize,
        .define_unforgeable_attributes = &TextDecoderPrototype::define_unforgeable_attributes,
        .construct = &TextDecoderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextDecoderStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextDecoderStream"sv,
        .namespaced_name = "TextDecoderStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextDecoderStreamConstructor::initialize,
        .initialize_prototype = &TextDecoderStreamPrototype::initialize,
        .define_unforgeable_attributes = &TextDecoderStreamPrototype::define_unforgeable_attributes,
        .construct = &TextDecoderStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextEncoderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextEncoder"sv,
        .namespaced_name = "TextEncoder"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextEncoderConstructor::initialize,
        .initialize_prototype = &TextEncoderPrototype::initialize,
        .define_unforgeable_attributes = &TextEncoderPrototype::define_unforgeable_attributes,
        .construct = &TextEncoderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextEncoderStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextEncoderStream"sv,
        .namespaced_name = "TextEncoderStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextEncoderStreamConstructor::initialize,
        .initialize_prototype = &TextEncoderStreamPrototype::initialize,
        .define_unforgeable_attributes = &TextEncoderStreamPrototype::define_unforgeable_attributes,
        .construct = &TextEncoderStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaKeySystemAccessPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaKeySystemAccess"sv,
        .namespaced_name = "MediaKeySystemAccess"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaKeySystemAccessConstructor::initialize,
        .initialize_prototype = &MediaKeySystemAccessPrototype::initialize,
        .define_unforgeable_attributes = &MediaKeySystemAccessPrototype::define_unforgeable_attributes,
        .construct = &MediaKeySystemAccessConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FileSystemEntryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FileSystemEntry"sv,
        .namespaced_name = "FileSystemEntry"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FileSystemEntryConstructor::initialize,
        .initialize_prototype = &FileSystemEntryPrototype::initialize,
        .define_unforgeable_attributes = &FileSystemEntryPrototype::define_unforgeable_attributes,
        .construct = &FileSystemEntryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceEventTimingPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceEventTiming"sv,
        .namespaced_name = "PerformanceEventTiming"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .initialize_constructor = &PerformanceEventTimingConstructor::initialize,
        .initialize_prototype = &PerformanceEventTimingPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceEventTimingPrototype::define_unforgeable_attributes,
        .construct = &PerformanceEventTimingConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HeadersPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Headers"sv,
        .namespaced_name = "Headers"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &HeadersConstructor::initialize,
        .construct = &HeadersConstructor::construct,
    };

    auto prototype = realm.create<HeadersPrototype>(realm);
    m_prototypes.set("Headers"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<RequestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Request"sv,
        .namespaced_name = "Request"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &RequestConstructor::initialize,
        .initialize_prototype = &RequestPrototype::initialize,
        .define_unforgeable_attributes = &RequestPrototype::define_unforgeable_attributes,
        .construct = &RequestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ResponsePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Response"sv,
        .namespaced_name = "Response"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ResponseConstructor::initialize,
        .initialize_prototype = &ResponsePrototype::initialize,
        .define_unforgeable_attributes = &ResponsePrototype::define_unforgeable_attributes,
        .construct = &ResponseConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BlobPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Blob"sv,
        .namespaced_name = "Blob"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &BlobConstructor::initialize,
        .initialize_prototype = &BlobPrototype::initialize,
        .define_unforgeable_attributes = &BlobPrototype::define_unforgeable_attributes,
        .construct = &BlobConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FilePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "File"sv,
        .namespaced_name = "File"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<BlobPrototype>(realm, "Blob"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<BlobPrototype>(realm, "Blob"_fly_string); },
        .initialize_constructor = &FileConstructor::initialize,
        .initialize_prototype = &FilePrototype::initialize,
        .define_unforgeable_attributes = &FilePrototype::define_unforgeable_attributes,
        .construct = &FileConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FileListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FileList"sv,
        .namespaced_name = "FileList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FileListConstructor::initialize,
        .construct = &FileListConstructor::construct,
    };

    auto prototype = realm.create<FileListPrototype>(realm);
    m_prototypes.set("FileList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FileReaderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FileReader"sv,
        .namespaced_name = "FileReader"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &FileReaderConstructor::initialize,
        .initialize_prototype = &FileReaderPrototype::initialize,
        .define_unforgeable_attributes = &FileReaderPrototype::define_unforgeable_attributes,
        .construct = &FileReaderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FileReaderSyncPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FileReaderSync"sv,
        .namespaced_name = "FileReaderSync"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FileReaderSyncConstructor::initialize,
        .initialize_prototype = &FileReaderSyncPrototype::initialize,
        .define_unforgeable_attributes = &FileReaderSyncPrototype::define_unforgeable_attributes,
        .construct = &FileReaderSyncConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GamepadPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Gamepad"sv,
        .namespaced_name = "Gamepad"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GamepadConstructor::initialize,
        .initialize_prototype = &GamepadPrototype::initialize,
        .define_unforgeable_attributes = &GamepadPrototype::define_unforgeable_attributes,
        .construct = &GamepadConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GamepadButtonPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GamepadButton"sv,
        .namespaced_name = "GamepadButton"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GamepadButtonConstructor::initialize,
        .initialize_prototype = &GamepadButtonPrototype::initialize,
        .define_unforgeable_attributes = &GamepadButtonPrototype::define_unforgeable_attributes,
        .construct = &GamepadButtonConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GamepadEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GamepadEvent"sv,
        .namespaced_name = "GamepadEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &GamepadEventConstructor::initialize,
        .initialize_prototype = &GamepadEventPrototype::initialize,
        .define_unforgeable_attributes = &GamepadEventPrototype::define_unforgeable_attributes,
        .construct = &GamepadEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GamepadHapticActuatorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GamepadHapticActuator"sv,
        .namespaced_name = "GamepadHapticActuator"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GamepadHapticActuatorConstructor::initialize,
        .initialize_prototype = &GamepadHapticActuatorPrototype::initialize,
        .define_unforgeable_attributes = &GamepadHapticActuatorPrototype::define_unforgeable_attributes,
        .construct = &GamepadHapticActuatorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GeolocationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Geolocation"sv,
        .namespaced_name = "Geolocation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GeolocationConstructor::initialize,
        .initialize_prototype = &GeolocationPrototype::initialize,
        .define_unforgeable_attributes = &GeolocationPrototype::define_unforgeable_attributes,
        .construct = &GeolocationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GeolocationCoordinatesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GeolocationCoordinates"sv,
        .namespaced_name = "GeolocationCoordinates"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GeolocationCoordinatesConstructor::initialize,
        .initialize_prototype = &GeolocationCoordinatesPrototype::initialize,
        .define_unforgeable_attributes = &GeolocationCoordinatesPrototype::define_unforgeable_attributes,
        .construct = &GeolocationCoordinatesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GeolocationPositionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GeolocationPosition"sv,
        .namespaced_name = "GeolocationPosition"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GeolocationPositionConstructor::initialize,
        .initialize_prototype = &GeolocationPositionPrototype::initialize,
        .define_unforgeable_attributes = &GeolocationPositionPrototype::define_unforgeable_attributes,
        .construct = &GeolocationPositionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GeolocationPositionErrorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GeolocationPositionError"sv,
        .namespaced_name = "GeolocationPositionError"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GeolocationPositionErrorConstructor::initialize,
        .initialize_prototype = &GeolocationPositionErrorPrototype::initialize,
        .define_unforgeable_attributes = &GeolocationPositionErrorPrototype::define_unforgeable_attributes,
        .construct = &GeolocationPositionErrorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMMatrixPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMMatrix"sv,
        .namespaced_name = "DOMMatrix"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DOMMatrixReadOnlyPrototype>(realm, "DOMMatrixReadOnly"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DOMMatrixReadOnlyPrototype>(realm, "DOMMatrixReadOnly"_fly_string); },
        .initialize_constructor = &DOMMatrixConstructor::initialize,
        .initialize_prototype = &DOMMatrixPrototype::initialize,
        .define_unforgeable_attributes = &DOMMatrixPrototype::define_unforgeable_attributes,
        .construct = &DOMMatrixConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMMatrixReadOnlyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMMatrixReadOnly"sv,
        .namespaced_name = "DOMMatrixReadOnly"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMMatrixReadOnlyConstructor::initialize,
        .initialize_prototype = &DOMMatrixReadOnlyPrototype::initialize,
        .define_unforgeable_attributes = &DOMMatrixReadOnlyPrototype::define_unforgeable_attributes,
        .construct = &DOMMatrixReadOnlyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMPointPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMPoint"sv,
        .namespaced_name = "DOMPoint"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DOMPointReadOnlyPrototype>(realm, "DOMPointReadOnly"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DOMPointReadOnlyPrototype>(realm, "DOMPointReadOnly"_fly_string); },
        .initialize_constructor = &DOMPointConstructor::initialize,
        .initialize_prototype = &DOMPointPrototype::initialize,
        .define_unforgeable_attributes = &DOMPointPrototype::define_unforgeable_attributes,
        .construct = &DOMPointConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMPointReadOnlyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMPointReadOnly"sv,
        .namespaced_name = "DOMPointReadOnly"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMPointReadOnlyConstructor::initialize,
        .initialize_prototype = &DOMPointReadOnlyPrototype::initialize,
        .define_unforgeable_attributes = &DOMPointReadOnlyPrototype::define_unforgeable_attributes,
        .construct = &DOMPointReadOnlyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMQuadPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMQuad"sv,
        .namespaced_name = "DOMQuad"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMQuadConstructor::initialize,
        .initialize_prototype = &DOMQuadPrototype::initialize,
        .define_unforgeable_attributes = &DOMQuadPrototype::define_unforgeable_attributes,
        .construct = &DOMQuadConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMRectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMRect"sv,
        .namespaced_name = "DOMRect"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DOMRectReadOnlyPrototype>(realm, "DOMRectReadOnly"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DOMRectReadOnlyPrototype>(realm, "DOMRectReadOnly"_fly_string); },
        .initialize_constructor = &DOMRectConstructor::initialize,
        .initialize_prototype = &DOMRectPrototype::initialize,
        .define_unforgeable_attributes = &DOMRectPrototype::define_unforgeable_attributes,
        .construct = &DOMRectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMRectListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMRectList"sv,
        .namespaced_name = "DOMRectList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMRectListConstructor::initialize,
        .construct = &DOMRectListConstructor::construct,
    };

    auto prototype = realm.create<DOMRectListPrototype>(realm);
    m_prototypes.set("DOMRectList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMRectReadOnlyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMRectReadOnly"sv,
        .namespaced_name = "DOMRectReadOnly"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMRectReadOnlyConstructor::initialize,
        .initialize_prototype = &DOMRectReadOnlyPrototype::initialize,
        .define_unforgeable_attributes = &DOMRectReadOnlyPrototype::define_unforgeable_attributes,
        .construct = &DOMRectReadOnlyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformancePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Performance"sv,
        .namespaced_name = "Performance"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &PerformanceConstructor::initialize,
        .initialize_prototype = &PerformancePrototype::initialize,
        .define_unforgeable_attributes = &PerformancePrototype::define_unforgeable_attributes,
        .construct = &PerformanceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioTrackPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioTrack"sv,
        .namespaced_name = "AudioTrack"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AudioTrackConstructor::initialize,
        .initialize_prototype = &AudioTrackPrototype::initialize,
        .define_unforgeable_attributes = &AudioTrackPrototype::define_unforgeable_attributes,
        .construct = &AudioTrackConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioTrackListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioTrackList"sv,
        .namespaced_name = "AudioTrackList"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &AudioTrackListConstructor::initialize,
        .construct = &AudioTrackListConstructor::construct,
    };

    auto prototype = realm.create<AudioTrackListPrototype>(realm);
    m_prototypes.set("AudioTrackList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BarPropPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BarProp"sv,
        .namespaced_name = "BarProp"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &BarPropConstructor::initialize,
        .initialize_prototype = &BarPropPrototype::initialize,
        .define_unforgeable_attributes = &BarPropPrototype::define_unforgeable_attributes,
        .construct = &BarPropConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BeforeUnloadEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BeforeUnloadEvent"sv,
        .namespaced_name = "BeforeUnloadEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &BeforeUnloadEventConstructor::initialize,
        .initialize_prototype = &BeforeUnloadEventPrototype::initialize,
        .define_unforgeable_attributes = &BeforeUnloadEventPrototype::define_unforgeable_attributes,
        .construct = &BeforeUnloadEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BroadcastChannelPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BroadcastChannel"sv,
        .namespaced_name = "BroadcastChannel"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &BroadcastChannelConstructor::initialize,
        .initialize_prototype = &BroadcastChannelPrototype::initialize,
        .define_unforgeable_attributes = &BroadcastChannelPrototype::define_unforgeable_attributes,
        .construct = &BroadcastChannelConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CanvasGradientPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CanvasGradient"sv,
        .namespaced_name = "CanvasGradient"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CanvasGradientConstructor::initialize,
        .initialize_prototype = &CanvasGradientPrototype::initialize,
        .define_unforgeable_attributes = &CanvasGradientPrototype::define_unforgeable_attributes,
        .construct = &CanvasGradientConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CanvasPatternPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CanvasPattern"sv,
        .namespaced_name = "CanvasPattern"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CanvasPatternConstructor::initialize,
        .initialize_prototype = &CanvasPatternPrototype::initialize,
        .define_unforgeable_attributes = &CanvasPatternPrototype::define_unforgeable_attributes,
        .construct = &CanvasPatternConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CanvasRenderingContext2DPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CanvasRenderingContext2D"sv,
        .namespaced_name = "CanvasRenderingContext2D"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CanvasRenderingContext2DConstructor::initialize,
        .initialize_prototype = &CanvasRenderingContext2DPrototype::initialize,
        .define_unforgeable_attributes = &CanvasRenderingContext2DPrototype::define_unforgeable_attributes,
        .construct = &CanvasRenderingContext2DConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CloseEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CloseEvent"sv,
        .namespaced_name = "CloseEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &CloseEventConstructor::initialize,
        .initialize_prototype = &CloseEventPrototype::initialize,
        .define_unforgeable_attributes = &CloseEventPrototype::define_unforgeable_attributes,
        .construct = &CloseEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CloseWatcherPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CloseWatcher"sv,
        .namespaced_name = "CloseWatcher"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &CloseWatcherConstructor::initialize,
        .initialize_prototype = &CloseWatcherPrototype::initialize,
        .define_unforgeable_attributes = &CloseWatcherPrototype::define_unforgeable_attributes,
        .construct = &CloseWatcherConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CommandEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CommandEvent"sv,
        .namespaced_name = "CommandEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &CommandEventConstructor::initialize,
        .initialize_prototype = &CommandEventPrototype::initialize,
        .define_unforgeable_attributes = &CommandEventPrototype::define_unforgeable_attributes,
        .construct = &CommandEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CustomElementRegistryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CustomElementRegistry"sv,
        .namespaced_name = "CustomElementRegistry"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CustomElementRegistryConstructor::initialize,
        .initialize_prototype = &CustomElementRegistryPrototype::initialize,
        .define_unforgeable_attributes = &CustomElementRegistryPrototype::define_unforgeable_attributes,
        .construct = &CustomElementRegistryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CustomStateSetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CustomStateSet"sv,
        .namespaced_name = "CustomStateSet"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CustomStateSetConstructor::initialize,
        .construct = &CustomStateSetConstructor::construct,
    };

    auto prototype = realm.create<CustomStateSetPrototype>(realm);
    m_prototypes.set("CustomStateSet"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DataTransferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DataTransfer"sv,
        .namespaced_name = "DataTransfer"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DataTransferConstructor::initialize,
        .initialize_prototype = &DataTransferPrototype::initialize,
        .define_unforgeable_attributes = &DataTransferPrototype::define_unforgeable_attributes,
        .construct = &DataTransferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DataTransferItemPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DataTransferItem"sv,
        .namespaced_name = "DataTransferItem"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DataTransferItemConstructor::initialize,
        .initialize_prototype = &DataTransferItemPrototype::initialize,
        .define_unforgeable_attributes = &DataTransferItemPrototype::define_unforgeable_attributes,
        .construct = &DataTransferItemConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DataTransferItemListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DataTransferItemList"sv,
        .namespaced_name = "DataTransferItemList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DataTransferItemListConstructor::initialize,
        .construct = &DataTransferItemListConstructor::construct,
    };

    auto prototype = realm.create<DataTransferItemListPrototype>(realm);
    m_prototypes.set("DataTransferItemList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DedicatedWorkerGlobalScopePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DedicatedWorkerGlobalScope"sv,
        .namespaced_name = "DedicatedWorkerGlobalScope"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WorkerGlobalScopePrototype>(realm, "WorkerGlobalScope"_fly_string); },
        .initialize_constructor = &DedicatedWorkerGlobalScopeConstructor::initialize,
        .construct = &DedicatedWorkerGlobalScopeConstructor::construct,
    };

    auto prototype = realm.create<DedicatedWorkerGlobalScopePrototype>(realm);
    m_prototypes.set("DedicatedWorkerGlobalScope"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMParserPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMParser"sv,
        .namespaced_name = "DOMParser"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMParserConstructor::initialize,
        .initialize_prototype = &DOMParserPrototype::initialize,
        .define_unforgeable_attributes = &DOMParserPrototype::define_unforgeable_attributes,
        .construct = &DOMParserConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMStringListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMStringList"sv,
        .namespaced_name = "DOMStringList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMStringListConstructor::initialize,
        .construct = &DOMStringListConstructor::construct,
    };

    auto prototype = realm.create<DOMStringListPrototype>(realm);
    m_prototypes.set("DOMStringList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMStringMapPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMStringMap"sv,
        .namespaced_name = "DOMStringMap"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMStringMapConstructor::initialize,
        .construct = &DOMStringMapConstructor::construct,
    };

    auto prototype = realm.create<DOMStringMapPrototype>(realm);
    m_prototypes.set("DOMStringMap"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DragEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DragEvent"sv,
        .namespaced_name = "DragEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .initialize_constructor = &DragEventConstructor::initialize,
        .initialize_prototype = &DragEventPrototype::initialize,
        .define_unforgeable_attributes = &DragEventPrototype::define_unforgeable_attributes,
        .construct = &DragEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ElementInternalsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ElementInternals"sv,
        .namespaced_name = "ElementInternals"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ElementInternalsConstructor::initialize,
        .initialize_prototype = &ElementInternalsPrototype::initialize,
        .define_unforgeable_attributes = &ElementInternalsPrototype::define_unforgeable_attributes,
        .construct = &ElementInternalsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ErrorEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ErrorEvent"sv,
        .namespaced_name = "ErrorEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &ErrorEventConstructor::initialize,
        .initialize_prototype = &ErrorEventPrototype::initialize,
        .define_unforgeable_attributes = &ErrorEventPrototype::define_unforgeable_attributes,
        .construct = &ErrorEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EventSourcePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EventSource"sv,
        .namespaced_name = "EventSource"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &EventSourceConstructor::initialize,
        .initialize_prototype = &EventSourcePrototype::initialize,
        .define_unforgeable_attributes = &EventSourcePrototype::define_unforgeable_attributes,
        .construct = &EventSourceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ExternalPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "External"sv,
        .namespaced_name = "External"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ExternalConstructor::initialize,
        .initialize_prototype = &ExternalPrototype::initialize,
        .define_unforgeable_attributes = &ExternalPrototype::define_unforgeable_attributes,
        .construct = &ExternalConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FormDataEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FormDataEvent"sv,
        .namespaced_name = "FormDataEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &FormDataEventConstructor::initialize,
        .initialize_prototype = &FormDataEventPrototype::initialize,
        .define_unforgeable_attributes = &FormDataEventPrototype::define_unforgeable_attributes,
        .construct = &FormDataEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HashChangeEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HashChangeEvent"sv,
        .namespaced_name = "HashChangeEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &HashChangeEventConstructor::initialize,
        .initialize_prototype = &HashChangeEventPrototype::initialize,
        .define_unforgeable_attributes = &HashChangeEventPrototype::define_unforgeable_attributes,
        .construct = &HashChangeEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HistoryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "History"sv,
        .namespaced_name = "History"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &HistoryConstructor::initialize,
        .initialize_prototype = &HistoryPrototype::initialize,
        .define_unforgeable_attributes = &HistoryPrototype::define_unforgeable_attributes,
        .construct = &HistoryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLAllCollectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLAllCollection"sv,
        .namespaced_name = "HTMLAllCollection"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &HTMLAllCollectionConstructor::initialize,
        .construct = &HTMLAllCollectionConstructor::construct,
    };

    auto prototype = realm.create<HTMLAllCollectionPrototype>(realm);
    m_prototypes.set("HTMLAllCollection"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLAnchorElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLAnchorElement"sv,
        .namespaced_name = "HTMLAnchorElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLAnchorElementConstructor::initialize,
        .initialize_prototype = &HTMLAnchorElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLAnchorElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLAnchorElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLAreaElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLAreaElement"sv,
        .namespaced_name = "HTMLAreaElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLAreaElementConstructor::initialize,
        .initialize_prototype = &HTMLAreaElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLAreaElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLAreaElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLAudioElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLAudioElement"sv,
        .namespaced_name = "HTMLAudioElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLMediaElementPrototype>(realm, "HTMLMediaElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLMediaElementPrototype>(realm, "HTMLMediaElement"_fly_string); },
        .initialize_constructor = &HTMLAudioElementConstructor::initialize,
        .initialize_prototype = &HTMLAudioElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLAudioElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLAudioElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
    auto legacy_constructor = realm.create<AudioConstructor>(realm);
    m_constructors.set("Audio"_fly_string, legacy_constructor.ptr());
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLBaseElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLBaseElement"sv,
        .namespaced_name = "HTMLBaseElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLBaseElementConstructor::initialize,
        .initialize_prototype = &HTMLBaseElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLBaseElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLBaseElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLBodyElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLBodyElement"sv,
        .namespaced_name = "HTMLBodyElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLBodyElementConstructor::initialize,
        .initialize_prototype = &HTMLBodyElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLBodyElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLBodyElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLBRElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLBRElement"sv,
        .namespaced_name = "HTMLBRElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLBRElementConstructor::initialize,
        .initialize_prototype = &HTMLBRElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLBRElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLBRElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLButtonElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLButtonElement"sv,
        .namespaced_name = "HTMLButtonElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLButtonElementConstructor::initialize,
        .initialize_prototype = &HTMLButtonElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLButtonElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLButtonElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLCanvasElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLCanvasElement"sv,
        .namespaced_name = "HTMLCanvasElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLCanvasElementConstructor::initialize,
        .initialize_prototype = &HTMLCanvasElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLCanvasElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLCanvasElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDataElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDataElement"sv,
        .namespaced_name = "HTMLDataElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDataElementConstructor::initialize,
        .initialize_prototype = &HTMLDataElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDataElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDataElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDataListElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDataListElement"sv,
        .namespaced_name = "HTMLDataListElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDataListElementConstructor::initialize,
        .initialize_prototype = &HTMLDataListElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDataListElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDataListElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDetailsElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDetailsElement"sv,
        .namespaced_name = "HTMLDetailsElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDetailsElementConstructor::initialize,
        .initialize_prototype = &HTMLDetailsElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDetailsElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDetailsElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDialogElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDialogElement"sv,
        .namespaced_name = "HTMLDialogElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDialogElementConstructor::initialize,
        .initialize_prototype = &HTMLDialogElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDialogElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDialogElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDirectoryElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDirectoryElement"sv,
        .namespaced_name = "HTMLDirectoryElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDirectoryElementConstructor::initialize,
        .initialize_prototype = &HTMLDirectoryElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDirectoryElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDirectoryElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDivElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDivElement"sv,
        .namespaced_name = "HTMLDivElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDivElementConstructor::initialize,
        .initialize_prototype = &HTMLDivElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDivElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDivElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDListElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDListElement"sv,
        .namespaced_name = "HTMLDListElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLDListElementConstructor::initialize,
        .initialize_prototype = &HTMLDListElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDListElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLDListElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLDocumentPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLDocument"sv,
        .namespaced_name = "HTMLDocument"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DocumentPrototype>(realm, "Document"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DocumentPrototype>(realm, "Document"_fly_string); },
        .initialize_constructor = &HTMLDocumentConstructor::initialize,
        .initialize_prototype = &HTMLDocumentPrototype::initialize,
        .define_unforgeable_attributes = &HTMLDocumentPrototype::define_unforgeable_attributes,
        .construct = &HTMLDocumentConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLElement"sv,
        .namespaced_name = "HTMLElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<ElementPrototype>(realm, "Element"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<ElementPrototype>(realm, "Element"_fly_string); },
        .initialize_constructor = &HTMLElementConstructor::initialize,
        .initialize_prototype = &HTMLElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLEmbedElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLEmbedElement"sv,
        .namespaced_name = "HTMLEmbedElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLEmbedElementConstructor::initialize,
        .initialize_prototype = &HTMLEmbedElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLEmbedElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLEmbedElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFieldSetElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFieldSetElement"sv,
        .namespaced_name = "HTMLFieldSetElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLFieldSetElementConstructor::initialize,
        .initialize_prototype = &HTMLFieldSetElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLFieldSetElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLFieldSetElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFontElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFontElement"sv,
        .namespaced_name = "HTMLFontElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLFontElementConstructor::initialize,
        .initialize_prototype = &HTMLFontElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLFontElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLFontElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFormControlsCollectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFormControlsCollection"sv,
        .namespaced_name = "HTMLFormControlsCollection"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLCollectionPrototype>(realm, "HTMLCollection"_fly_string); },
        .initialize_constructor = &HTMLFormControlsCollectionConstructor::initialize,
        .construct = &HTMLFormControlsCollectionConstructor::construct,
    };

    auto prototype = realm.create<HTMLFormControlsCollectionPrototype>(realm);
    m_prototypes.set("HTMLFormControlsCollection"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFormElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFormElement"sv,
        .namespaced_name = "HTMLFormElement"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLFormElementConstructor::initialize,
        .construct = &HTMLFormElementConstructor::construct,
    };

    auto prototype = realm.create<HTMLFormElementPrototype>(realm);
    m_prototypes.set("HTMLFormElement"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFrameElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFrameElement"sv,
        .namespaced_name = "HTMLFrameElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLFrameElementConstructor::initialize,
        .initialize_prototype = &HTMLFrameElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLFrameElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLFrameElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLFrameSetElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLFrameSetElement"sv,
        .namespaced_name = "HTMLFrameSetElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLFrameSetElementConstructor::initialize,
        .initialize_prototype = &HTMLFrameSetElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLFrameSetElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLFrameSetElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLHeadElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLHeadElement"sv,
        .namespaced_name = "HTMLHeadElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLHeadElementConstructor::initialize,
        .initialize_prototype = &HTMLHeadElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLHeadElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLHeadElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLHeadingElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLHeadingElement"sv,
        .namespaced_name = "HTMLHeadingElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLHeadingElementConstructor::initialize,
        .initialize_prototype = &HTMLHeadingElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLHeadingElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLHeadingElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLHRElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLHRElement"sv,
        .namespaced_name = "HTMLHRElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLHRElementConstructor::initialize,
        .initialize_prototype = &HTMLHRElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLHRElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLHRElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLHtmlElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLHtmlElement"sv,
        .namespaced_name = "HTMLHtmlElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLHtmlElementConstructor::initialize,
        .initialize_prototype = &HTMLHtmlElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLHtmlElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLHtmlElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLIFrameElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLIFrameElement"sv,
        .namespaced_name = "HTMLIFrameElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLIFrameElementConstructor::initialize,
        .initialize_prototype = &HTMLIFrameElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLIFrameElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLIFrameElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLImageElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLImageElement"sv,
        .namespaced_name = "HTMLImageElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLImageElementConstructor::initialize,
        .initialize_prototype = &HTMLImageElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLImageElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLImageElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
    auto legacy_constructor = realm.create<ImageConstructor>(realm);
    m_constructors.set("Image"_fly_string, legacy_constructor.ptr());
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLInputElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLInputElement"sv,
        .namespaced_name = "HTMLInputElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLInputElementConstructor::initialize,
        .initialize_prototype = &HTMLInputElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLInputElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLInputElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLLabelElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLLabelElement"sv,
        .namespaced_name = "HTMLLabelElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLLabelElementConstructor::initialize,
        .initialize_prototype = &HTMLLabelElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLLabelElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLLabelElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLLegendElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLLegendElement"sv,
        .namespaced_name = "HTMLLegendElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLLegendElementConstructor::initialize,
        .initialize_prototype = &HTMLLegendElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLLegendElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLLegendElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLLIElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLLIElement"sv,
        .namespaced_name = "HTMLLIElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLLIElementConstructor::initialize,
        .initialize_prototype = &HTMLLIElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLLIElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLLIElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLLinkElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLLinkElement"sv,
        .namespaced_name = "HTMLLinkElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLLinkElementConstructor::initialize,
        .initialize_prototype = &HTMLLinkElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLLinkElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLLinkElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMapElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMapElement"sv,
        .namespaced_name = "HTMLMapElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMapElementConstructor::initialize,
        .initialize_prototype = &HTMLMapElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMapElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMapElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMarqueeElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMarqueeElement"sv,
        .namespaced_name = "HTMLMarqueeElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMarqueeElementConstructor::initialize,
        .initialize_prototype = &HTMLMarqueeElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMarqueeElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMarqueeElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMediaElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMediaElement"sv,
        .namespaced_name = "HTMLMediaElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMediaElementConstructor::initialize,
        .initialize_prototype = &HTMLMediaElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMediaElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMediaElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMenuElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMenuElement"sv,
        .namespaced_name = "HTMLMenuElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMenuElementConstructor::initialize,
        .initialize_prototype = &HTMLMenuElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMenuElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMenuElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMetaElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMetaElement"sv,
        .namespaced_name = "HTMLMetaElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMetaElementConstructor::initialize,
        .initialize_prototype = &HTMLMetaElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMetaElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMetaElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLMeterElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLMeterElement"sv,
        .namespaced_name = "HTMLMeterElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLMeterElementConstructor::initialize,
        .initialize_prototype = &HTMLMeterElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLMeterElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLMeterElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLModElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLModElement"sv,
        .namespaced_name = "HTMLModElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLModElementConstructor::initialize,
        .initialize_prototype = &HTMLModElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLModElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLModElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLObjectElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLObjectElement"sv,
        .namespaced_name = "HTMLObjectElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLObjectElementConstructor::initialize,
        .initialize_prototype = &HTMLObjectElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLObjectElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLObjectElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLOListElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLOListElement"sv,
        .namespaced_name = "HTMLOListElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLOListElementConstructor::initialize,
        .initialize_prototype = &HTMLOListElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLOListElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLOListElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLOptGroupElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLOptGroupElement"sv,
        .namespaced_name = "HTMLOptGroupElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLOptGroupElementConstructor::initialize,
        .initialize_prototype = &HTMLOptGroupElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLOptGroupElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLOptGroupElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLOptionElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLOptionElement"sv,
        .namespaced_name = "HTMLOptionElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLOptionElementConstructor::initialize,
        .initialize_prototype = &HTMLOptionElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLOptionElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLOptionElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
    auto legacy_constructor = realm.create<OptionConstructor>(realm);
    m_constructors.set("Option"_fly_string, legacy_constructor.ptr());
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLOptionsCollectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLOptionsCollection"sv,
        .namespaced_name = "HTMLOptionsCollection"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLCollectionPrototype>(realm, "HTMLCollection"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLCollectionPrototype>(realm, "HTMLCollection"_fly_string); },
        .initialize_constructor = &HTMLOptionsCollectionConstructor::initialize,
        .initialize_prototype = &HTMLOptionsCollectionPrototype::initialize,
        .define_unforgeable_attributes = &HTMLOptionsCollectionPrototype::define_unforgeable_attributes,
        .construct = &HTMLOptionsCollectionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLOutputElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLOutputElement"sv,
        .namespaced_name = "HTMLOutputElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLOutputElementConstructor::initialize,
        .initialize_prototype = &HTMLOutputElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLOutputElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLOutputElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLParagraphElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLParagraphElement"sv,
        .namespaced_name = "HTMLParagraphElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLParagraphElementConstructor::initialize,
        .initialize_prototype = &HTMLParagraphElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLParagraphElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLParagraphElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLParamElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLParamElement"sv,
        .namespaced_name = "HTMLParamElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLParamElementConstructor::initialize,
        .initialize_prototype = &HTMLParamElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLParamElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLParamElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLPictureElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLPictureElement"sv,
        .namespaced_name = "HTMLPictureElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLPictureElementConstructor::initialize,
        .initialize_prototype = &HTMLPictureElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLPictureElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLPictureElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLPreElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLPreElement"sv,
        .namespaced_name = "HTMLPreElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLPreElementConstructor::initialize,
        .initialize_prototype = &HTMLPreElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLPreElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLPreElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLProgressElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLProgressElement"sv,
        .namespaced_name = "HTMLProgressElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLProgressElementConstructor::initialize,
        .initialize_prototype = &HTMLProgressElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLProgressElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLProgressElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLQuoteElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLQuoteElement"sv,
        .namespaced_name = "HTMLQuoteElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLQuoteElementConstructor::initialize,
        .initialize_prototype = &HTMLQuoteElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLQuoteElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLQuoteElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLScriptElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLScriptElement"sv,
        .namespaced_name = "HTMLScriptElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLScriptElementConstructor::initialize,
        .initialize_prototype = &HTMLScriptElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLScriptElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLScriptElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLSelectedContentElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLSelectedContentElement"sv,
        .namespaced_name = "HTMLSelectedContentElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLSelectedContentElementConstructor::initialize,
        .initialize_prototype = &HTMLSelectedContentElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLSelectedContentElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLSelectedContentElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLSelectElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLSelectElement"sv,
        .namespaced_name = "HTMLSelectElement"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLSelectElementConstructor::initialize,
        .construct = &HTMLSelectElementConstructor::construct,
    };

    auto prototype = realm.create<HTMLSelectElementPrototype>(realm);
    m_prototypes.set("HTMLSelectElement"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLSlotElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLSlotElement"sv,
        .namespaced_name = "HTMLSlotElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLSlotElementConstructor::initialize,
        .initialize_prototype = &HTMLSlotElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLSlotElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLSlotElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLSourceElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLSourceElement"sv,
        .namespaced_name = "HTMLSourceElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLSourceElementConstructor::initialize,
        .initialize_prototype = &HTMLSourceElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLSourceElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLSourceElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLSpanElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLSpanElement"sv,
        .namespaced_name = "HTMLSpanElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLSpanElementConstructor::initialize,
        .initialize_prototype = &HTMLSpanElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLSpanElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLSpanElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLStyleElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLStyleElement"sv,
        .namespaced_name = "HTMLStyleElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLStyleElementConstructor::initialize,
        .initialize_prototype = &HTMLStyleElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLStyleElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLStyleElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableCaptionElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableCaptionElement"sv,
        .namespaced_name = "HTMLTableCaptionElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableCaptionElementConstructor::initialize,
        .initialize_prototype = &HTMLTableCaptionElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableCaptionElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableCaptionElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableCellElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableCellElement"sv,
        .namespaced_name = "HTMLTableCellElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableCellElementConstructor::initialize,
        .initialize_prototype = &HTMLTableCellElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableCellElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableCellElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableColElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableColElement"sv,
        .namespaced_name = "HTMLTableColElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableColElementConstructor::initialize,
        .initialize_prototype = &HTMLTableColElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableColElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableColElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableElement"sv,
        .namespaced_name = "HTMLTableElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableElementConstructor::initialize,
        .initialize_prototype = &HTMLTableElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableRowElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableRowElement"sv,
        .namespaced_name = "HTMLTableRowElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableRowElementConstructor::initialize,
        .initialize_prototype = &HTMLTableRowElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableRowElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableRowElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTableSectionElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTableSectionElement"sv,
        .namespaced_name = "HTMLTableSectionElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTableSectionElementConstructor::initialize,
        .initialize_prototype = &HTMLTableSectionElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTableSectionElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTableSectionElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTemplateElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTemplateElement"sv,
        .namespaced_name = "HTMLTemplateElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTemplateElementConstructor::initialize,
        .initialize_prototype = &HTMLTemplateElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTemplateElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTemplateElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTextAreaElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTextAreaElement"sv,
        .namespaced_name = "HTMLTextAreaElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTextAreaElementConstructor::initialize,
        .initialize_prototype = &HTMLTextAreaElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTextAreaElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTextAreaElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTimeElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTimeElement"sv,
        .namespaced_name = "HTMLTimeElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTimeElementConstructor::initialize,
        .initialize_prototype = &HTMLTimeElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTimeElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTimeElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTitleElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTitleElement"sv,
        .namespaced_name = "HTMLTitleElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTitleElementConstructor::initialize,
        .initialize_prototype = &HTMLTitleElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTitleElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTitleElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLTrackElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLTrackElement"sv,
        .namespaced_name = "HTMLTrackElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLTrackElementConstructor::initialize,
        .initialize_prototype = &HTMLTrackElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLTrackElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLTrackElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLUListElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLUListElement"sv,
        .namespaced_name = "HTMLUListElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLUListElementConstructor::initialize,
        .initialize_prototype = &HTMLUListElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLUListElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLUListElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLUnknownElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLUnknownElement"sv,
        .namespaced_name = "HTMLUnknownElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLElementPrototype>(realm, "HTMLElement"_fly_string); },
        .initialize_constructor = &HTMLUnknownElementConstructor::initialize,
        .initialize_prototype = &HTMLUnknownElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLUnknownElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLUnknownElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<HTMLVideoElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "HTMLVideoElement"sv,
        .namespaced_name = "HTMLVideoElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<HTMLMediaElementPrototype>(realm, "HTMLMediaElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<HTMLMediaElementPrototype>(realm, "HTMLMediaElement"_fly_string); },
        .initialize_constructor = &HTMLVideoElementConstructor::initialize,
        .initialize_prototype = &HTMLVideoElementPrototype::initialize,
        .define_unforgeable_attributes = &HTMLVideoElementPrototype::define_unforgeable_attributes,
        .construct = &HTMLVideoElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ImageBitmapPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ImageBitmap"sv,
        .namespaced_name = "ImageBitmap"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ImageBitmapConstructor::initialize,
        .initialize_prototype = &ImageBitmapPrototype::initialize,
        .define_unforgeable_attributes = &ImageBitmapPrototype::define_unforgeable_attributes,
        .construct = &ImageBitmapConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ImageDataPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ImageData"sv,
        .namespaced_name = "ImageData"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ImageDataConstructor::initialize,
        .initialize_prototype = &ImageDataPrototype::initialize,
        .define_unforgeable_attributes = &ImageDataPrototype::define_unforgeable_attributes,
        .construct = &ImageDataConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<LocationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Location"sv,
        .namespaced_name = "Location"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &LocationConstructor::initialize,
        .initialize_prototype = &LocationPrototype::initialize,
        .define_unforgeable_attributes = &LocationPrototype::define_unforgeable_attributes,
        .construct = &LocationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaErrorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaError"sv,
        .namespaced_name = "MediaError"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaErrorConstructor::initialize,
        .initialize_prototype = &MediaErrorPrototype::initialize,
        .define_unforgeable_attributes = &MediaErrorPrototype::define_unforgeable_attributes,
        .construct = &MediaErrorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MessageChannelPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MessageChannel"sv,
        .namespaced_name = "MessageChannel"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MessageChannelConstructor::initialize,
        .initialize_prototype = &MessageChannelPrototype::initialize,
        .define_unforgeable_attributes = &MessageChannelPrototype::define_unforgeable_attributes,
        .construct = &MessageChannelConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MessageEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MessageEvent"sv,
        .namespaced_name = "MessageEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &MessageEventConstructor::initialize,
        .initialize_prototype = &MessageEventPrototype::initialize,
        .define_unforgeable_attributes = &MessageEventPrototype::define_unforgeable_attributes,
        .construct = &MessageEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MessagePortPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MessagePort"sv,
        .namespaced_name = "MessagePort"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MessagePortConstructor::initialize,
        .initialize_prototype = &MessagePortPrototype::initialize,
        .define_unforgeable_attributes = &MessagePortPrototype::define_unforgeable_attributes,
        .construct = &MessagePortConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MimeTypePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MimeType"sv,
        .namespaced_name = "MimeType"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MimeTypeConstructor::initialize,
        .initialize_prototype = &MimeTypePrototype::initialize,
        .define_unforgeable_attributes = &MimeTypePrototype::define_unforgeable_attributes,
        .construct = &MimeTypeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MimeTypeArrayPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MimeTypeArray"sv,
        .namespaced_name = "MimeTypeArray"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MimeTypeArrayConstructor::initialize,
        .construct = &MimeTypeArrayConstructor::construct,
    };

    auto prototype = realm.create<MimeTypeArrayPrototype>(realm);
    m_prototypes.set("MimeTypeArray"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigateEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NavigateEvent"sv,
        .namespaced_name = "NavigateEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &NavigateEventConstructor::initialize,
        .initialize_prototype = &NavigateEventPrototype::initialize,
        .define_unforgeable_attributes = &NavigateEventPrototype::define_unforgeable_attributes,
        .construct = &NavigateEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Navigation"sv,
        .namespaced_name = "Navigation"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &NavigationConstructor::initialize,
        .initialize_prototype = &NavigationPrototype::initialize,
        .define_unforgeable_attributes = &NavigationPrototype::define_unforgeable_attributes,
        .construct = &NavigationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigationCurrentEntryChangeEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NavigationCurrentEntryChangeEvent"sv,
        .namespaced_name = "NavigationCurrentEntryChangeEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &NavigationCurrentEntryChangeEventConstructor::initialize,
        .initialize_prototype = &NavigationCurrentEntryChangeEventPrototype::initialize,
        .define_unforgeable_attributes = &NavigationCurrentEntryChangeEventPrototype::define_unforgeable_attributes,
        .construct = &NavigationCurrentEntryChangeEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigationDestinationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NavigationDestination"sv,
        .namespaced_name = "NavigationDestination"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NavigationDestinationConstructor::initialize,
        .initialize_prototype = &NavigationDestinationPrototype::initialize,
        .define_unforgeable_attributes = &NavigationDestinationPrototype::define_unforgeable_attributes,
        .construct = &NavigationDestinationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigationHistoryEntryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NavigationHistoryEntry"sv,
        .namespaced_name = "NavigationHistoryEntry"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &NavigationHistoryEntryConstructor::initialize,
        .initialize_prototype = &NavigationHistoryEntryPrototype::initialize,
        .define_unforgeable_attributes = &NavigationHistoryEntryPrototype::define_unforgeable_attributes,
        .construct = &NavigationHistoryEntryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigationTransitionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "NavigationTransition"sv,
        .namespaced_name = "NavigationTransition"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NavigationTransitionConstructor::initialize,
        .initialize_prototype = &NavigationTransitionPrototype::initialize,
        .define_unforgeable_attributes = &NavigationTransitionPrototype::define_unforgeable_attributes,
        .construct = &NavigationTransitionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NavigatorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Navigator"sv,
        .namespaced_name = "Navigator"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &NavigatorConstructor::initialize,
        .initialize_prototype = &NavigatorPrototype::initialize,
        .define_unforgeable_attributes = &NavigatorPrototype::define_unforgeable_attributes,
        .construct = &NavigatorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OffscreenCanvasPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OffscreenCanvas"sv,
        .namespaced_name = "OffscreenCanvas"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &OffscreenCanvasConstructor::initialize,
        .initialize_prototype = &OffscreenCanvasPrototype::initialize,
        .define_unforgeable_attributes = &OffscreenCanvasPrototype::define_unforgeable_attributes,
        .construct = &OffscreenCanvasConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OffscreenCanvasRenderingContext2DPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OffscreenCanvasRenderingContext2D"sv,
        .namespaced_name = "OffscreenCanvasRenderingContext2D"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &OffscreenCanvasRenderingContext2DConstructor::initialize,
        .initialize_prototype = &OffscreenCanvasRenderingContext2DPrototype::initialize,
        .define_unforgeable_attributes = &OffscreenCanvasRenderingContext2DPrototype::define_unforgeable_attributes,
        .construct = &OffscreenCanvasRenderingContext2DConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PageTransitionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PageTransitionEvent"sv,
        .namespaced_name = "PageTransitionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &PageTransitionEventConstructor::initialize,
        .initialize_prototype = &PageTransitionEventPrototype::initialize,
        .define_unforgeable_attributes = &PageTransitionEventPrototype::define_unforgeable_attributes,
        .construct = &PageTransitionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<Path2DPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Path2D"sv,
        .namespaced_name = "Path2D"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &Path2DConstructor::initialize,
        .initialize_prototype = &Path2DPrototype::initialize,
        .define_unforgeable_attributes = &Path2DPrototype::define_unforgeable_attributes,
        .construct = &Path2DConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PluginPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Plugin"sv,
        .namespaced_name = "Plugin"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PluginConstructor::initialize,
        .construct = &PluginConstructor::construct,
    };

    auto prototype = realm.create<PluginPrototype>(realm);
    m_prototypes.set("Plugin"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PluginArrayPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PluginArray"sv,
        .namespaced_name = "PluginArray"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PluginArrayConstructor::initialize,
        .construct = &PluginArrayConstructor::construct,
    };

    auto prototype = realm.create<PluginArrayPrototype>(realm);
    m_prototypes.set("PluginArray"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PopStateEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PopStateEvent"sv,
        .namespaced_name = "PopStateEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &PopStateEventConstructor::initialize,
        .initialize_prototype = &PopStateEventPrototype::initialize,
        .define_unforgeable_attributes = &PopStateEventPrototype::define_unforgeable_attributes,
        .construct = &PopStateEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PromiseRejectionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PromiseRejectionEvent"sv,
        .namespaced_name = "PromiseRejectionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &PromiseRejectionEventConstructor::initialize,
        .initialize_prototype = &PromiseRejectionEventPrototype::initialize,
        .define_unforgeable_attributes = &PromiseRejectionEventPrototype::define_unforgeable_attributes,
        .construct = &PromiseRejectionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<RadioNodeListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "RadioNodeList"sv,
        .namespaced_name = "RadioNodeList"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<NodeListPrototype>(realm, "NodeList"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<NodeListPrototype>(realm, "NodeList"_fly_string); },
        .initialize_constructor = &RadioNodeListConstructor::initialize,
        .initialize_prototype = &RadioNodeListPrototype::initialize,
        .define_unforgeable_attributes = &RadioNodeListPrototype::define_unforgeable_attributes,
        .construct = &RadioNodeListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SharedWorkerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SharedWorker"sv,
        .namespaced_name = "SharedWorker"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SharedWorkerConstructor::initialize,
        .initialize_prototype = &SharedWorkerPrototype::initialize,
        .define_unforgeable_attributes = &SharedWorkerPrototype::define_unforgeable_attributes,
        .construct = &SharedWorkerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SharedWorkerGlobalScopePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SharedWorkerGlobalScope"sv,
        .namespaced_name = "SharedWorkerGlobalScope"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WorkerGlobalScopePrototype>(realm, "WorkerGlobalScope"_fly_string); },
        .initialize_constructor = &SharedWorkerGlobalScopeConstructor::initialize,
        .construct = &SharedWorkerGlobalScopeConstructor::construct,
    };

    auto prototype = realm.create<SharedWorkerGlobalScopePrototype>(realm);
    m_prototypes.set("SharedWorkerGlobalScope"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StoragePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Storage"sv,
        .namespaced_name = "Storage"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &StorageConstructor::initialize,
        .construct = &StorageConstructor::construct,
    };

    auto prototype = realm.create<StoragePrototype>(realm);
    m_prototypes.set("Storage"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StorageEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StorageEvent"sv,
        .namespaced_name = "StorageEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &StorageEventConstructor::initialize,
        .initialize_prototype = &StorageEventPrototype::initialize,
        .define_unforgeable_attributes = &StorageEventPrototype::define_unforgeable_attributes,
        .construct = &StorageEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SubmitEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SubmitEvent"sv,
        .namespaced_name = "SubmitEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &SubmitEventConstructor::initialize,
        .initialize_prototype = &SubmitEventPrototype::initialize,
        .define_unforgeable_attributes = &SubmitEventPrototype::define_unforgeable_attributes,
        .construct = &SubmitEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextMetricsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextMetrics"sv,
        .namespaced_name = "TextMetrics"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextMetricsConstructor::initialize,
        .initialize_prototype = &TextMetricsPrototype::initialize,
        .define_unforgeable_attributes = &TextMetricsPrototype::define_unforgeable_attributes,
        .construct = &TextMetricsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextTrackPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextTrack"sv,
        .namespaced_name = "TextTrack"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &TextTrackConstructor::initialize,
        .initialize_prototype = &TextTrackPrototype::initialize,
        .define_unforgeable_attributes = &TextTrackPrototype::define_unforgeable_attributes,
        .construct = &TextTrackConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextTrackCuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextTrackCue"sv,
        .namespaced_name = "TextTrackCue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &TextTrackCueConstructor::initialize,
        .initialize_prototype = &TextTrackCuePrototype::initialize,
        .define_unforgeable_attributes = &TextTrackCuePrototype::define_unforgeable_attributes,
        .construct = &TextTrackCueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextTrackCueListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextTrackCueList"sv,
        .namespaced_name = "TextTrackCueList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TextTrackCueListConstructor::initialize,
        .construct = &TextTrackCueListConstructor::construct,
    };

    auto prototype = realm.create<TextTrackCueListPrototype>(realm);
    m_prototypes.set("TextTrackCueList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextTrackListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextTrackList"sv,
        .namespaced_name = "TextTrackList"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &TextTrackListConstructor::initialize,
        .construct = &TextTrackListConstructor::construct,
    };

    auto prototype = realm.create<TextTrackListPrototype>(realm);
    m_prototypes.set("TextTrackList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TimeRangesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TimeRanges"sv,
        .namespaced_name = "TimeRanges"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TimeRangesConstructor::initialize,
        .initialize_prototype = &TimeRangesPrototype::initialize,
        .define_unforgeable_attributes = &TimeRangesPrototype::define_unforgeable_attributes,
        .construct = &TimeRangesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ToggleEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ToggleEvent"sv,
        .namespaced_name = "ToggleEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &ToggleEventConstructor::initialize,
        .initialize_prototype = &ToggleEventPrototype::initialize,
        .define_unforgeable_attributes = &ToggleEventPrototype::define_unforgeable_attributes,
        .construct = &ToggleEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrackEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrackEvent"sv,
        .namespaced_name = "TrackEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &TrackEventConstructor::initialize,
        .initialize_prototype = &TrackEventPrototype::initialize,
        .define_unforgeable_attributes = &TrackEventPrototype::define_unforgeable_attributes,
        .construct = &TrackEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<UserActivationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "UserActivation"sv,
        .namespaced_name = "UserActivation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &UserActivationConstructor::initialize,
        .initialize_prototype = &UserActivationPrototype::initialize,
        .define_unforgeable_attributes = &UserActivationPrototype::define_unforgeable_attributes,
        .construct = &UserActivationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ValidityStatePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ValidityState"sv,
        .namespaced_name = "ValidityState"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ValidityStateConstructor::initialize,
        .initialize_prototype = &ValidityStatePrototype::initialize,
        .define_unforgeable_attributes = &ValidityStatePrototype::define_unforgeable_attributes,
        .construct = &ValidityStateConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<VideoTrackPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "VideoTrack"sv,
        .namespaced_name = "VideoTrack"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &VideoTrackConstructor::initialize,
        .initialize_prototype = &VideoTrackPrototype::initialize,
        .define_unforgeable_attributes = &VideoTrackPrototype::define_unforgeable_attributes,
        .construct = &VideoTrackConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<VideoTrackListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "VideoTrackList"sv,
        .namespaced_name = "VideoTrackList"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &VideoTrackListConstructor::initialize,
        .construct = &VideoTrackListConstructor::construct,
    };

    auto prototype = realm.create<VideoTrackListPrototype>(realm);
    m_prototypes.set("VideoTrackList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WindowPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Window"sv,
        .namespaced_name = "Window"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &WindowConstructor::initialize,
        .construct = &WindowConstructor::construct,
    };

    auto named_properties_object = realm.create<WindowProperties>(realm);
    m_prototypes.set("WindowProperties"_fly_string, named_properties_object);

    auto prototype = realm.create<WindowPrototype>(realm);
    m_prototypes.set("Window"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WorkerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Worker"sv,
        .namespaced_name = "Worker"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &WorkerConstructor::initialize,
        .initialize_prototype = &WorkerPrototype::initialize,
        .define_unforgeable_attributes = &WorkerPrototype::define_unforgeable_attributes,
        .construct = &WorkerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WorkerGlobalScopePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WorkerGlobalScope"sv,
        .namespaced_name = "WorkerGlobalScope"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &WorkerGlobalScopeConstructor::initialize,
        .initialize_prototype = &WorkerGlobalScopePrototype::initialize,
        .define_unforgeable_attributes = &WorkerGlobalScopePrototype::define_unforgeable_attributes,
        .construct = &WorkerGlobalScopeConstructor::construct,
        .has_immutable_prototype = true,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WorkerLocationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WorkerLocation"sv,
        .namespaced_name = "WorkerLocation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WorkerLocationConstructor::initialize,
        .initialize_prototype = &WorkerLocationPrototype::initialize,
        .define_unforgeable_attributes = &WorkerLocationPrototype::define_unforgeable_attributes,
        .construct = &WorkerLocationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WorkerNavigatorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WorkerNavigator"sv,
        .namespaced_name = "WorkerNavigator"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WorkerNavigatorConstructor::initialize,
        .initialize_prototype = &WorkerNavigatorPrototype::initialize,
        .define_unforgeable_attributes = &WorkerNavigatorPrototype::define_unforgeable_attributes,
        .construct = &WorkerNavigatorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WorkletGlobalScopePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WorkletGlobalScope"sv,
        .namespaced_name = "WorkletGlobalScope"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WorkletGlobalScopeConstructor::initialize,
        .initialize_prototype = &WorkletGlobalScopePrototype::initialize,
        .define_unforgeable_attributes = &WorkletGlobalScopePrototype::define_unforgeable_attributes,
        .construct = &WorkletGlobalScopeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XMLSerializerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XMLSerializer"sv,
        .namespaced_name = "XMLSerializer"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XMLSerializerConstructor::initialize,
        .initialize_prototype = &XMLSerializerPrototype::initialize,
        .define_unforgeable_attributes = &XMLSerializerPrototype::define_unforgeable_attributes,
        .construct = &XMLSerializerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBCursorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBCursor"sv,
        .namespaced_name = "IDBCursor"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBCursorConstructor::initialize,
        .initialize_prototype = &IDBCursorPrototype::initialize,
        .define_unforgeable_attributes = &IDBCursorPrototype::define_unforgeable_attributes,
        .construct = &IDBCursorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBCursorWithValuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBCursorWithValue"sv,
        .namespaced_name = "IDBCursorWithValue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<IDBCursorPrototype>(realm, "IDBCursor"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<IDBCursorPrototype>(realm, "IDBCursor"_fly_string); },
        .initialize_constructor = &IDBCursorWithValueConstructor::initialize,
        .initialize_prototype = &IDBCursorWithValuePrototype::initialize,
        .define_unforgeable_attributes = &IDBCursorWithValuePrototype::define_unforgeable_attributes,
        .construct = &IDBCursorWithValueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBDatabasePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBDatabase"sv,
        .namespaced_name = "IDBDatabase"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &IDBDatabaseConstructor::initialize,
        .initialize_prototype = &IDBDatabasePrototype::initialize,
        .define_unforgeable_attributes = &IDBDatabasePrototype::define_unforgeable_attributes,
        .construct = &IDBDatabaseConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBFactoryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBFactory"sv,
        .namespaced_name = "IDBFactory"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBFactoryConstructor::initialize,
        .initialize_prototype = &IDBFactoryPrototype::initialize,
        .define_unforgeable_attributes = &IDBFactoryPrototype::define_unforgeable_attributes,
        .construct = &IDBFactoryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBIndexPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBIndex"sv,
        .namespaced_name = "IDBIndex"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBIndexConstructor::initialize,
        .initialize_prototype = &IDBIndexPrototype::initialize,
        .define_unforgeable_attributes = &IDBIndexPrototype::define_unforgeable_attributes,
        .construct = &IDBIndexConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBKeyRangePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBKeyRange"sv,
        .namespaced_name = "IDBKeyRange"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBKeyRangeConstructor::initialize,
        .initialize_prototype = &IDBKeyRangePrototype::initialize,
        .define_unforgeable_attributes = &IDBKeyRangePrototype::define_unforgeable_attributes,
        .construct = &IDBKeyRangeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBObjectStorePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBObjectStore"sv,
        .namespaced_name = "IDBObjectStore"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBObjectStoreConstructor::initialize,
        .initialize_prototype = &IDBObjectStorePrototype::initialize,
        .define_unforgeable_attributes = &IDBObjectStorePrototype::define_unforgeable_attributes,
        .construct = &IDBObjectStoreConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBOpenDBRequestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBOpenDBRequest"sv,
        .namespaced_name = "IDBOpenDBRequest"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<IDBRequestPrototype>(realm, "IDBRequest"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<IDBRequestPrototype>(realm, "IDBRequest"_fly_string); },
        .initialize_constructor = &IDBOpenDBRequestConstructor::initialize,
        .initialize_prototype = &IDBOpenDBRequestPrototype::initialize,
        .define_unforgeable_attributes = &IDBOpenDBRequestPrototype::define_unforgeable_attributes,
        .construct = &IDBOpenDBRequestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBRecordPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBRecord"sv,
        .namespaced_name = "IDBRecord"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IDBRecordConstructor::initialize,
        .initialize_prototype = &IDBRecordPrototype::initialize,
        .define_unforgeable_attributes = &IDBRecordPrototype::define_unforgeable_attributes,
        .construct = &IDBRecordConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBRequestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBRequest"sv,
        .namespaced_name = "IDBRequest"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &IDBRequestConstructor::initialize,
        .initialize_prototype = &IDBRequestPrototype::initialize,
        .define_unforgeable_attributes = &IDBRequestPrototype::define_unforgeable_attributes,
        .construct = &IDBRequestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBTransactionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBTransaction"sv,
        .namespaced_name = "IDBTransaction"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &IDBTransactionConstructor::initialize,
        .initialize_prototype = &IDBTransactionPrototype::initialize,
        .define_unforgeable_attributes = &IDBTransactionPrototype::define_unforgeable_attributes,
        .construct = &IDBTransactionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IDBVersionChangeEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IDBVersionChangeEvent"sv,
        .namespaced_name = "IDBVersionChangeEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &IDBVersionChangeEventConstructor::initialize,
        .initialize_prototype = &IDBVersionChangeEventPrototype::initialize,
        .define_unforgeable_attributes = &IDBVersionChangeEventPrototype::define_unforgeable_attributes,
        .construct = &IDBVersionChangeEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FakeXRDevicePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FakeXRDevice"sv,
        .namespaced_name = "FakeXRDevice"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FakeXRDeviceConstructor::initialize,
        .initialize_prototype = &FakeXRDevicePrototype::initialize,
        .define_unforgeable_attributes = &FakeXRDevicePrototype::define_unforgeable_attributes,
        .construct = &FakeXRDeviceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<InternalAnimationTimelinePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "InternalAnimationTimeline"sv,
        .namespaced_name = "InternalAnimationTimeline"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AnimationTimelinePrototype>(realm, "AnimationTimeline"_fly_string); },
        .initialize_constructor = &InternalAnimationTimelineConstructor::initialize,
        .initialize_prototype = &InternalAnimationTimelinePrototype::initialize,
        .define_unforgeable_attributes = &InternalAnimationTimelinePrototype::define_unforgeable_attributes,
        .construct = &InternalAnimationTimelineConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<InternalGamepadPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "InternalGamepad"sv,
        .namespaced_name = "InternalGamepad"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &InternalGamepadConstructor::initialize,
        .initialize_prototype = &InternalGamepadPrototype::initialize,
        .define_unforgeable_attributes = &InternalGamepadPrototype::define_unforgeable_attributes,
        .construct = &InternalGamepadConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<InternalsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Internals"sv,
        .namespaced_name = "Internals"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &InternalsConstructor::initialize,
        .initialize_prototype = &InternalsPrototype::initialize,
        .define_unforgeable_attributes = &InternalsPrototype::define_unforgeable_attributes,
        .construct = &InternalsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebUIPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebUI"sv,
        .namespaced_name = "WebUI"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebUIConstructor::initialize,
        .initialize_prototype = &WebUIPrototype::initialize,
        .define_unforgeable_attributes = &WebUIPrototype::define_unforgeable_attributes,
        .construct = &WebUIConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRTestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRTest"sv,
        .namespaced_name = "XRTest"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XRTestConstructor::initialize,
        .initialize_prototype = &XRTestPrototype::initialize,
        .define_unforgeable_attributes = &XRTestPrototype::define_unforgeable_attributes,
        .construct = &XRTestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IntersectionObserverPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IntersectionObserver"sv,
        .namespaced_name = "IntersectionObserver"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IntersectionObserverConstructor::initialize,
        .initialize_prototype = &IntersectionObserverPrototype::initialize,
        .define_unforgeable_attributes = &IntersectionObserverPrototype::define_unforgeable_attributes,
        .construct = &IntersectionObserverConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IntersectionObserverEntryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IntersectionObserverEntry"sv,
        .namespaced_name = "IntersectionObserverEntry"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IntersectionObserverEntryConstructor::initialize,
        .initialize_prototype = &IntersectionObserverEntryPrototype::initialize,
        .define_unforgeable_attributes = &IntersectionObserverEntryPrototype::define_unforgeable_attributes,
        .construct = &IntersectionObserverEntryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MathMLElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MathMLElement"sv,
        .namespaced_name = "MathMLElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<ElementPrototype>(realm, "Element"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<ElementPrototype>(realm, "Element"_fly_string); },
        .initialize_constructor = &MathMLElementConstructor::initialize,
        .initialize_prototype = &MathMLElementPrototype::initialize,
        .define_unforgeable_attributes = &MathMLElementPrototype::define_unforgeable_attributes,
        .construct = &MathMLElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaCapabilitiesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaCapabilities"sv,
        .namespaced_name = "MediaCapabilities"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaCapabilitiesConstructor::initialize,
        .initialize_prototype = &MediaCapabilitiesPrototype::initialize,
        .define_unforgeable_attributes = &MediaCapabilitiesPrototype::define_unforgeable_attributes,
        .construct = &MediaCapabilitiesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaDeviceInfoPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaDeviceInfo"sv,
        .namespaced_name = "MediaDeviceInfo"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaDeviceInfoConstructor::initialize,
        .initialize_prototype = &MediaDeviceInfoPrototype::initialize,
        .define_unforgeable_attributes = &MediaDeviceInfoPrototype::define_unforgeable_attributes,
        .construct = &MediaDeviceInfoConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaDevicesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaDevices"sv,
        .namespaced_name = "MediaDevices"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MediaDevicesConstructor::initialize,
        .initialize_prototype = &MediaDevicesPrototype::initialize,
        .define_unforgeable_attributes = &MediaDevicesPrototype::define_unforgeable_attributes,
        .construct = &MediaDevicesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaStream"sv,
        .namespaced_name = "MediaStream"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MediaStreamConstructor::initialize,
        .initialize_prototype = &MediaStreamPrototype::initialize,
        .define_unforgeable_attributes = &MediaStreamPrototype::define_unforgeable_attributes,
        .construct = &MediaStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaStreamTrackPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaStreamTrack"sv,
        .namespaced_name = "MediaStreamTrack"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MediaStreamTrackConstructor::initialize,
        .initialize_prototype = &MediaStreamTrackPrototype::initialize,
        .define_unforgeable_attributes = &MediaStreamTrackPrototype::define_unforgeable_attributes,
        .construct = &MediaStreamTrackConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaStreamTrackEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaStreamTrackEvent"sv,
        .namespaced_name = "MediaStreamTrackEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &MediaStreamTrackEventConstructor::initialize,
        .initialize_prototype = &MediaStreamTrackEventPrototype::initialize,
        .define_unforgeable_attributes = &MediaStreamTrackEventPrototype::define_unforgeable_attributes,
        .construct = &MediaStreamTrackEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BufferedChangeEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BufferedChangeEvent"sv,
        .namespaced_name = "BufferedChangeEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &BufferedChangeEventConstructor::initialize,
        .initialize_prototype = &BufferedChangeEventPrototype::initialize,
        .define_unforgeable_attributes = &BufferedChangeEventPrototype::define_unforgeable_attributes,
        .construct = &BufferedChangeEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ManagedMediaSourcePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ManagedMediaSource"sv,
        .namespaced_name = "ManagedMediaSource"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<MediaSourcePrototype>(realm, "MediaSource"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<MediaSourcePrototype>(realm, "MediaSource"_fly_string); },
        .initialize_constructor = &ManagedMediaSourceConstructor::initialize,
        .initialize_prototype = &ManagedMediaSourcePrototype::initialize,
        .define_unforgeable_attributes = &ManagedMediaSourcePrototype::define_unforgeable_attributes,
        .construct = &ManagedMediaSourceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ManagedSourceBufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ManagedSourceBuffer"sv,
        .namespaced_name = "ManagedSourceBuffer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SourceBufferPrototype>(realm, "SourceBuffer"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SourceBufferPrototype>(realm, "SourceBuffer"_fly_string); },
        .initialize_constructor = &ManagedSourceBufferConstructor::initialize,
        .initialize_prototype = &ManagedSourceBufferPrototype::initialize,
        .define_unforgeable_attributes = &ManagedSourceBufferPrototype::define_unforgeable_attributes,
        .construct = &ManagedSourceBufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaSourcePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaSource"sv,
        .namespaced_name = "MediaSource"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &MediaSourceConstructor::initialize,
        .initialize_prototype = &MediaSourcePrototype::initialize,
        .define_unforgeable_attributes = &MediaSourcePrototype::define_unforgeable_attributes,
        .construct = &MediaSourceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaSourceHandlePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaSourceHandle"sv,
        .namespaced_name = "MediaSourceHandle"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MediaSourceHandleConstructor::initialize,
        .initialize_prototype = &MediaSourceHandlePrototype::initialize,
        .define_unforgeable_attributes = &MediaSourceHandlePrototype::define_unforgeable_attributes,
        .construct = &MediaSourceHandleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SourceBufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SourceBuffer"sv,
        .namespaced_name = "SourceBuffer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SourceBufferConstructor::initialize,
        .initialize_prototype = &SourceBufferPrototype::initialize,
        .define_unforgeable_attributes = &SourceBufferPrototype::define_unforgeable_attributes,
        .construct = &SourceBufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SourceBufferListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SourceBufferList"sv,
        .namespaced_name = "SourceBufferList"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SourceBufferListConstructor::initialize,
        .construct = &SourceBufferListConstructor::construct,
    };

    auto prototype = realm.create<SourceBufferListPrototype>(realm);
    m_prototypes.set("SourceBufferList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceNavigationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceNavigation"sv,
        .namespaced_name = "PerformanceNavigation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PerformanceNavigationConstructor::initialize,
        .initialize_prototype = &PerformanceNavigationPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceNavigationPrototype::define_unforgeable_attributes,
        .construct = &PerformanceNavigationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceTimingPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceTiming"sv,
        .namespaced_name = "PerformanceTiming"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PerformanceTimingConstructor::initialize,
        .initialize_prototype = &PerformanceTimingPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceTimingPrototype::define_unforgeable_attributes,
        .construct = &PerformanceTimingConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<NotificationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Notification"sv,
        .namespaced_name = "Notification"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &NotificationConstructor::initialize,
        .initialize_prototype = &NotificationPrototype::initialize,
        .define_unforgeable_attributes = &NotificationPrototype::define_unforgeable_attributes,
        .construct = &NotificationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceEntryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceEntry"sv,
        .namespaced_name = "PerformanceEntry"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PerformanceEntryConstructor::initialize,
        .initialize_prototype = &PerformanceEntryPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceEntryPrototype::define_unforgeable_attributes,
        .construct = &PerformanceEntryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceObserverPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceObserver"sv,
        .namespaced_name = "PerformanceObserver"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PerformanceObserverConstructor::initialize,
        .initialize_prototype = &PerformanceObserverPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceObserverPrototype::define_unforgeable_attributes,
        .construct = &PerformanceObserverConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceObserverEntryListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceObserverEntryList"sv,
        .namespaced_name = "PerformanceObserverEntryList"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PerformanceObserverEntryListConstructor::initialize,
        .initialize_prototype = &PerformanceObserverEntryListPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceObserverEntryListPrototype::define_unforgeable_attributes,
        .construct = &PerformanceObserverEntryListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PermissionsPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Permissions"sv,
        .namespaced_name = "Permissions"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PermissionsConstructor::initialize,
        .initialize_prototype = &PermissionsPrototype::initialize,
        .define_unforgeable_attributes = &PermissionsPrototype::define_unforgeable_attributes,
        .construct = &PermissionsConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PermissionStatusPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PermissionStatus"sv,
        .namespaced_name = "PermissionStatus"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &PermissionStatusConstructor::initialize,
        .initialize_prototype = &PermissionStatusPrototype::initialize,
        .define_unforgeable_attributes = &PermissionStatusPrototype::define_unforgeable_attributes,
        .construct = &PermissionStatusConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<IdleDeadlinePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "IdleDeadline"sv,
        .namespaced_name = "IdleDeadline"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &IdleDeadlineConstructor::initialize,
        .initialize_prototype = &IdleDeadlinePrototype::initialize,
        .define_unforgeable_attributes = &IdleDeadlinePrototype::define_unforgeable_attributes,
        .construct = &IdleDeadlineConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ResizeObserverPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ResizeObserver"sv,
        .namespaced_name = "ResizeObserver"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ResizeObserverConstructor::initialize,
        .initialize_prototype = &ResizeObserverPrototype::initialize,
        .define_unforgeable_attributes = &ResizeObserverPrototype::define_unforgeable_attributes,
        .construct = &ResizeObserverConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ResizeObserverEntryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ResizeObserverEntry"sv,
        .namespaced_name = "ResizeObserverEntry"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ResizeObserverEntryConstructor::initialize,
        .initialize_prototype = &ResizeObserverEntryPrototype::initialize,
        .define_unforgeable_attributes = &ResizeObserverEntryPrototype::define_unforgeable_attributes,
        .construct = &ResizeObserverEntryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ResizeObserverSizePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ResizeObserverSize"sv,
        .namespaced_name = "ResizeObserverSize"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ResizeObserverSizeConstructor::initialize,
        .initialize_prototype = &ResizeObserverSizePrototype::initialize,
        .define_unforgeable_attributes = &ResizeObserverSizePrototype::define_unforgeable_attributes,
        .construct = &ResizeObserverSizeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceResourceTimingPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceResourceTiming"sv,
        .namespaced_name = "PerformanceResourceTiming"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .initialize_constructor = &PerformanceResourceTimingConstructor::initialize,
        .initialize_prototype = &PerformanceResourceTimingPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceResourceTimingPrototype::define_unforgeable_attributes,
        .construct = &PerformanceResourceTimingConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SelectionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Selection"sv,
        .namespaced_name = "Selection"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SelectionConstructor::initialize,
        .initialize_prototype = &SelectionPrototype::initialize,
        .define_unforgeable_attributes = &SelectionPrototype::define_unforgeable_attributes,
        .construct = &SelectionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SerialPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Serial"sv,
        .namespaced_name = "Serial"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SerialConstructor::initialize,
        .initialize_prototype = &SerialPrototype::initialize,
        .define_unforgeable_attributes = &SerialPrototype::define_unforgeable_attributes,
        .construct = &SerialConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SerialPortPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SerialPort"sv,
        .namespaced_name = "SerialPort"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SerialPortConstructor::initialize,
        .initialize_prototype = &SerialPortPrototype::initialize,
        .define_unforgeable_attributes = &SerialPortPrototype::define_unforgeable_attributes,
        .construct = &SerialPortConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CachePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Cache"sv,
        .namespaced_name = "Cache"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CacheConstructor::initialize,
        .initialize_prototype = &CachePrototype::initialize,
        .define_unforgeable_attributes = &CachePrototype::define_unforgeable_attributes,
        .construct = &CacheConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CacheStoragePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CacheStorage"sv,
        .namespaced_name = "CacheStorage"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CacheStorageConstructor::initialize,
        .initialize_prototype = &CacheStoragePrototype::initialize,
        .define_unforgeable_attributes = &CacheStoragePrototype::define_unforgeable_attributes,
        .construct = &CacheStorageConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ServiceWorkerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ServiceWorker"sv,
        .namespaced_name = "ServiceWorker"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &ServiceWorkerConstructor::initialize,
        .initialize_prototype = &ServiceWorkerPrototype::initialize,
        .define_unforgeable_attributes = &ServiceWorkerPrototype::define_unforgeable_attributes,
        .construct = &ServiceWorkerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ServiceWorkerContainerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ServiceWorkerContainer"sv,
        .namespaced_name = "ServiceWorkerContainer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &ServiceWorkerContainerConstructor::initialize,
        .initialize_prototype = &ServiceWorkerContainerPrototype::initialize,
        .define_unforgeable_attributes = &ServiceWorkerContainerPrototype::define_unforgeable_attributes,
        .construct = &ServiceWorkerContainerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ServiceWorkerGlobalScopePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ServiceWorkerGlobalScope"sv,
        .namespaced_name = "ServiceWorkerGlobalScope"sv,
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WorkerGlobalScopePrototype>(realm, "WorkerGlobalScope"_fly_string); },
        .initialize_constructor = &ServiceWorkerGlobalScopeConstructor::initialize,
        .construct = &ServiceWorkerGlobalScopeConstructor::construct,
    };

    auto prototype = realm.create<ServiceWorkerGlobalScopePrototype>(realm);
    m_prototypes.set("ServiceWorkerGlobalScope"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ServiceWorkerRegistrationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ServiceWorkerRegistration"sv,
        .namespaced_name = "ServiceWorkerRegistration"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &ServiceWorkerRegistrationConstructor::initialize,
        .initialize_prototype = &ServiceWorkerRegistrationPrototype::initialize,
        .define_unforgeable_attributes = &ServiceWorkerRegistrationPrototype::define_unforgeable_attributes,
        .construct = &ServiceWorkerRegistrationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechGrammarPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechGrammar"sv,
        .namespaced_name = "SpeechGrammar"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechGrammarConstructor::initialize,
        .initialize_prototype = &SpeechGrammarPrototype::initialize,
        .define_unforgeable_attributes = &SpeechGrammarPrototype::define_unforgeable_attributes,
        .construct = &SpeechGrammarConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechGrammarListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechGrammarList"sv,
        .namespaced_name = "SpeechGrammarList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechGrammarListConstructor::initialize,
        .construct = &SpeechGrammarListConstructor::construct,
    };

    auto prototype = realm.create<SpeechGrammarListPrototype>(realm);
    m_prototypes.set("SpeechGrammarList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognition"sv,
        .namespaced_name = "SpeechRecognition"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SpeechRecognitionConstructor::initialize,
        .initialize_prototype = &SpeechRecognitionPrototype::initialize,
        .define_unforgeable_attributes = &SpeechRecognitionPrototype::define_unforgeable_attributes,
        .construct = &SpeechRecognitionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionAlternativePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognitionAlternative"sv,
        .namespaced_name = "SpeechRecognitionAlternative"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechRecognitionAlternativeConstructor::initialize,
        .initialize_prototype = &SpeechRecognitionAlternativePrototype::initialize,
        .define_unforgeable_attributes = &SpeechRecognitionAlternativePrototype::define_unforgeable_attributes,
        .construct = &SpeechRecognitionAlternativeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognitionEvent"sv,
        .namespaced_name = "SpeechRecognitionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &SpeechRecognitionEventConstructor::initialize,
        .initialize_prototype = &SpeechRecognitionEventPrototype::initialize,
        .define_unforgeable_attributes = &SpeechRecognitionEventPrototype::define_unforgeable_attributes,
        .construct = &SpeechRecognitionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionPhrasePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognitionPhrase"sv,
        .namespaced_name = "SpeechRecognitionPhrase"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechRecognitionPhraseConstructor::initialize,
        .initialize_prototype = &SpeechRecognitionPhrasePrototype::initialize,
        .define_unforgeable_attributes = &SpeechRecognitionPhrasePrototype::define_unforgeable_attributes,
        .construct = &SpeechRecognitionPhraseConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionResultPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognitionResult"sv,
        .namespaced_name = "SpeechRecognitionResult"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechRecognitionResultConstructor::initialize,
        .construct = &SpeechRecognitionResultConstructor::construct,
    };

    auto prototype = realm.create<SpeechRecognitionResultPrototype>(realm);
    m_prototypes.set("SpeechRecognitionResult"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechRecognitionResultListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechRecognitionResultList"sv,
        .namespaced_name = "SpeechRecognitionResultList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechRecognitionResultListConstructor::initialize,
        .construct = &SpeechRecognitionResultListConstructor::construct,
    };

    auto prototype = realm.create<SpeechRecognitionResultListPrototype>(realm);
    m_prototypes.set("SpeechRecognitionResultList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechSynthesisPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechSynthesis"sv,
        .namespaced_name = "SpeechSynthesis"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SpeechSynthesisConstructor::initialize,
        .initialize_prototype = &SpeechSynthesisPrototype::initialize,
        .define_unforgeable_attributes = &SpeechSynthesisPrototype::define_unforgeable_attributes,
        .construct = &SpeechSynthesisConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechSynthesisUtterancePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechSynthesisUtterance"sv,
        .namespaced_name = "SpeechSynthesisUtterance"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &SpeechSynthesisUtteranceConstructor::initialize,
        .initialize_prototype = &SpeechSynthesisUtterancePrototype::initialize,
        .define_unforgeable_attributes = &SpeechSynthesisUtterancePrototype::define_unforgeable_attributes,
        .construct = &SpeechSynthesisUtteranceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SpeechSynthesisVoicePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SpeechSynthesisVoice"sv,
        .namespaced_name = "SpeechSynthesisVoice"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SpeechSynthesisVoiceConstructor::initialize,
        .initialize_prototype = &SpeechSynthesisVoicePrototype::initialize,
        .define_unforgeable_attributes = &SpeechSynthesisVoicePrototype::define_unforgeable_attributes,
        .construct = &SpeechSynthesisVoiceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StorageManagerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StorageManager"sv,
        .namespaced_name = "StorageManager"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &StorageManagerConstructor::initialize,
        .initialize_prototype = &StorageManagerPrototype::initialize,
        .define_unforgeable_attributes = &StorageManagerPrototype::define_unforgeable_attributes,
        .construct = &StorageManagerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ByteLengthQueuingStrategyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ByteLengthQueuingStrategy"sv,
        .namespaced_name = "ByteLengthQueuingStrategy"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ByteLengthQueuingStrategyConstructor::initialize,
        .initialize_prototype = &ByteLengthQueuingStrategyPrototype::initialize,
        .define_unforgeable_attributes = &ByteLengthQueuingStrategyPrototype::define_unforgeable_attributes,
        .construct = &ByteLengthQueuingStrategyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CountQueuingStrategyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CountQueuingStrategy"sv,
        .namespaced_name = "CountQueuingStrategy"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &CountQueuingStrategyConstructor::initialize,
        .initialize_prototype = &CountQueuingStrategyPrototype::initialize,
        .define_unforgeable_attributes = &CountQueuingStrategyPrototype::define_unforgeable_attributes,
        .construct = &CountQueuingStrategyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableByteStreamControllerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableByteStreamController"sv,
        .namespaced_name = "ReadableByteStreamController"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableByteStreamControllerConstructor::initialize,
        .initialize_prototype = &ReadableByteStreamControllerPrototype::initialize,
        .define_unforgeable_attributes = &ReadableByteStreamControllerPrototype::define_unforgeable_attributes,
        .construct = &ReadableByteStreamControllerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableStream"sv,
        .namespaced_name = "ReadableStream"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableStreamConstructor::initialize,
        .construct = &ReadableStreamConstructor::construct,
    };

    auto prototype = realm.create<ReadableStreamPrototype>(realm);
    m_prototypes.set("ReadableStream"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableStreamBYOBReaderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableStreamBYOBReader"sv,
        .namespaced_name = "ReadableStreamBYOBReader"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableStreamBYOBReaderConstructor::initialize,
        .initialize_prototype = &ReadableStreamBYOBReaderPrototype::initialize,
        .define_unforgeable_attributes = &ReadableStreamBYOBReaderPrototype::define_unforgeable_attributes,
        .construct = &ReadableStreamBYOBReaderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableStreamBYOBRequestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableStreamBYOBRequest"sv,
        .namespaced_name = "ReadableStreamBYOBRequest"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableStreamBYOBRequestConstructor::initialize,
        .initialize_prototype = &ReadableStreamBYOBRequestPrototype::initialize,
        .define_unforgeable_attributes = &ReadableStreamBYOBRequestPrototype::define_unforgeable_attributes,
        .construct = &ReadableStreamBYOBRequestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableStreamDefaultControllerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableStreamDefaultController"sv,
        .namespaced_name = "ReadableStreamDefaultController"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableStreamDefaultControllerConstructor::initialize,
        .initialize_prototype = &ReadableStreamDefaultControllerPrototype::initialize,
        .define_unforgeable_attributes = &ReadableStreamDefaultControllerPrototype::define_unforgeable_attributes,
        .construct = &ReadableStreamDefaultControllerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ReadableStreamDefaultReaderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ReadableStreamDefaultReader"sv,
        .namespaced_name = "ReadableStreamDefaultReader"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ReadableStreamDefaultReaderConstructor::initialize,
        .initialize_prototype = &ReadableStreamDefaultReaderPrototype::initialize,
        .define_unforgeable_attributes = &ReadableStreamDefaultReaderPrototype::define_unforgeable_attributes,
        .construct = &ReadableStreamDefaultReaderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TransformStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TransformStream"sv,
        .namespaced_name = "TransformStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TransformStreamConstructor::initialize,
        .initialize_prototype = &TransformStreamPrototype::initialize,
        .define_unforgeable_attributes = &TransformStreamPrototype::define_unforgeable_attributes,
        .construct = &TransformStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TransformStreamDefaultControllerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TransformStreamDefaultController"sv,
        .namespaced_name = "TransformStreamDefaultController"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TransformStreamDefaultControllerConstructor::initialize,
        .initialize_prototype = &TransformStreamDefaultControllerPrototype::initialize,
        .define_unforgeable_attributes = &TransformStreamDefaultControllerPrototype::define_unforgeable_attributes,
        .construct = &TransformStreamDefaultControllerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WritableStreamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WritableStream"sv,
        .namespaced_name = "WritableStream"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WritableStreamConstructor::initialize,
        .initialize_prototype = &WritableStreamPrototype::initialize,
        .define_unforgeable_attributes = &WritableStreamPrototype::define_unforgeable_attributes,
        .construct = &WritableStreamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WritableStreamDefaultControllerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WritableStreamDefaultController"sv,
        .namespaced_name = "WritableStreamDefaultController"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WritableStreamDefaultControllerConstructor::initialize,
        .initialize_prototype = &WritableStreamDefaultControllerPrototype::initialize,
        .define_unforgeable_attributes = &WritableStreamDefaultControllerPrototype::define_unforgeable_attributes,
        .construct = &WritableStreamDefaultControllerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WritableStreamDefaultWriterPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WritableStreamDefaultWriter"sv,
        .namespaced_name = "WritableStreamDefaultWriter"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WritableStreamDefaultWriterConstructor::initialize,
        .initialize_prototype = &WritableStreamDefaultWriterPrototype::initialize,
        .define_unforgeable_attributes = &WritableStreamDefaultWriterPrototype::define_unforgeable_attributes,
        .construct = &WritableStreamDefaultWriterConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAElement"sv,
        .namespaced_name = "SVGAElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGAElementConstructor::initialize,
        .initialize_prototype = &SVGAElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGAElementPrototype::define_unforgeable_attributes,
        .construct = &SVGAElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedEnumerationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedEnumeration"sv,
        .namespaced_name = "SVGAnimatedEnumeration"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedEnumerationConstructor::initialize,
        .initialize_prototype = &SVGAnimatedEnumerationPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedEnumerationPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedEnumerationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedIntegerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedInteger"sv,
        .namespaced_name = "SVGAnimatedInteger"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedIntegerConstructor::initialize,
        .initialize_prototype = &SVGAnimatedIntegerPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedIntegerPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedIntegerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedLengthPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedLength"sv,
        .namespaced_name = "SVGAnimatedLength"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedLengthConstructor::initialize,
        .initialize_prototype = &SVGAnimatedLengthPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedLengthPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedLengthConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedLengthListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedLengthList"sv,
        .namespaced_name = "SVGAnimatedLengthList"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedLengthListConstructor::initialize,
        .initialize_prototype = &SVGAnimatedLengthListPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedLengthListPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedLengthListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedNumberPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedNumber"sv,
        .namespaced_name = "SVGAnimatedNumber"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedNumberConstructor::initialize,
        .initialize_prototype = &SVGAnimatedNumberPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedNumberPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedNumberConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedNumberListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedNumberList"sv,
        .namespaced_name = "SVGAnimatedNumberList"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedNumberListConstructor::initialize,
        .initialize_prototype = &SVGAnimatedNumberListPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedNumberListPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedNumberListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedRectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedRect"sv,
        .namespaced_name = "SVGAnimatedRect"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedRectConstructor::initialize,
        .initialize_prototype = &SVGAnimatedRectPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedRectPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedRectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedStringPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedString"sv,
        .namespaced_name = "SVGAnimatedString"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedStringConstructor::initialize,
        .initialize_prototype = &SVGAnimatedStringPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedStringPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedStringConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimatedTransformListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimatedTransformList"sv,
        .namespaced_name = "SVGAnimatedTransformList"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGAnimatedTransformListConstructor::initialize,
        .initialize_prototype = &SVGAnimatedTransformListPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimatedTransformListPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimatedTransformListConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGAnimationElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGAnimationElement"sv,
        .namespaced_name = "SVGAnimationElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGAnimationElementConstructor::initialize,
        .initialize_prototype = &SVGAnimationElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGAnimationElementPrototype::define_unforgeable_attributes,
        .construct = &SVGAnimationElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGCircleElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGCircleElement"sv,
        .namespaced_name = "SVGCircleElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGCircleElementConstructor::initialize,
        .initialize_prototype = &SVGCircleElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGCircleElementPrototype::define_unforgeable_attributes,
        .construct = &SVGCircleElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGClipPathElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGClipPathElement"sv,
        .namespaced_name = "SVGClipPathElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGClipPathElementConstructor::initialize,
        .initialize_prototype = &SVGClipPathElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGClipPathElementPrototype::define_unforgeable_attributes,
        .construct = &SVGClipPathElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGComponentTransferFunctionElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGComponentTransferFunctionElement"sv,
        .namespaced_name = "SVGComponentTransferFunctionElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGComponentTransferFunctionElementConstructor::initialize,
        .initialize_prototype = &SVGComponentTransferFunctionElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGComponentTransferFunctionElementPrototype::define_unforgeable_attributes,
        .construct = &SVGComponentTransferFunctionElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGDefsElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGDefsElement"sv,
        .namespaced_name = "SVGDefsElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGDefsElementConstructor::initialize,
        .initialize_prototype = &SVGDefsElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGDefsElementPrototype::define_unforgeable_attributes,
        .construct = &SVGDefsElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGDescElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGDescElement"sv,
        .namespaced_name = "SVGDescElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGDescElementConstructor::initialize,
        .initialize_prototype = &SVGDescElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGDescElementPrototype::define_unforgeable_attributes,
        .construct = &SVGDescElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGElement"sv,
        .namespaced_name = "SVGElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<ElementPrototype>(realm, "Element"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<ElementPrototype>(realm, "Element"_fly_string); },
        .initialize_constructor = &SVGElementConstructor::initialize,
        .initialize_prototype = &SVGElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGElementPrototype::define_unforgeable_attributes,
        .construct = &SVGElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGEllipseElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGEllipseElement"sv,
        .namespaced_name = "SVGEllipseElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGEllipseElementConstructor::initialize,
        .initialize_prototype = &SVGEllipseElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGEllipseElementPrototype::define_unforgeable_attributes,
        .construct = &SVGEllipseElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEBlendElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEBlendElement"sv,
        .namespaced_name = "SVGFEBlendElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEBlendElementConstructor::initialize,
        .initialize_prototype = &SVGFEBlendElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEBlendElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEBlendElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEColorMatrixElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEColorMatrixElement"sv,
        .namespaced_name = "SVGFEColorMatrixElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEColorMatrixElementConstructor::initialize,
        .initialize_prototype = &SVGFEColorMatrixElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEColorMatrixElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEColorMatrixElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEComponentTransferElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEComponentTransferElement"sv,
        .namespaced_name = "SVGFEComponentTransferElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEComponentTransferElementConstructor::initialize,
        .initialize_prototype = &SVGFEComponentTransferElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEComponentTransferElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEComponentTransferElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFECompositeElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFECompositeElement"sv,
        .namespaced_name = "SVGFECompositeElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFECompositeElementConstructor::initialize,
        .initialize_prototype = &SVGFECompositeElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFECompositeElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFECompositeElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEDisplacementMapElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEDisplacementMapElement"sv,
        .namespaced_name = "SVGFEDisplacementMapElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEDisplacementMapElementConstructor::initialize,
        .initialize_prototype = &SVGFEDisplacementMapElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEDisplacementMapElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEDisplacementMapElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEDropShadowElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEDropShadowElement"sv,
        .namespaced_name = "SVGFEDropShadowElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEDropShadowElementConstructor::initialize,
        .initialize_prototype = &SVGFEDropShadowElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEDropShadowElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEDropShadowElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEFloodElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEFloodElement"sv,
        .namespaced_name = "SVGFEFloodElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEFloodElementConstructor::initialize,
        .initialize_prototype = &SVGFEFloodElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEFloodElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEFloodElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEFuncAElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEFuncAElement"sv,
        .namespaced_name = "SVGFEFuncAElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .initialize_constructor = &SVGFEFuncAElementConstructor::initialize,
        .initialize_prototype = &SVGFEFuncAElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEFuncAElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEFuncAElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEFuncBElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEFuncBElement"sv,
        .namespaced_name = "SVGFEFuncBElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .initialize_constructor = &SVGFEFuncBElementConstructor::initialize,
        .initialize_prototype = &SVGFEFuncBElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEFuncBElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEFuncBElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEFuncGElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEFuncGElement"sv,
        .namespaced_name = "SVGFEFuncGElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .initialize_constructor = &SVGFEFuncGElementConstructor::initialize,
        .initialize_prototype = &SVGFEFuncGElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEFuncGElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEFuncGElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEFuncRElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEFuncRElement"sv,
        .namespaced_name = "SVGFEFuncRElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGComponentTransferFunctionElementPrototype>(realm, "SVGComponentTransferFunctionElement"_fly_string); },
        .initialize_constructor = &SVGFEFuncRElementConstructor::initialize,
        .initialize_prototype = &SVGFEFuncRElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEFuncRElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEFuncRElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEGaussianBlurElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEGaussianBlurElement"sv,
        .namespaced_name = "SVGFEGaussianBlurElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEGaussianBlurElementConstructor::initialize,
        .initialize_prototype = &SVGFEGaussianBlurElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEGaussianBlurElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEGaussianBlurElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEImageElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEImageElement"sv,
        .namespaced_name = "SVGFEImageElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEImageElementConstructor::initialize,
        .initialize_prototype = &SVGFEImageElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEImageElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEImageElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEMergeElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEMergeElement"sv,
        .namespaced_name = "SVGFEMergeElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEMergeElementConstructor::initialize,
        .initialize_prototype = &SVGFEMergeElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEMergeElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEMergeElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEMergeNodeElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEMergeNodeElement"sv,
        .namespaced_name = "SVGFEMergeNodeElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEMergeNodeElementConstructor::initialize,
        .initialize_prototype = &SVGFEMergeNodeElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEMergeNodeElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEMergeNodeElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEMorphologyElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEMorphologyElement"sv,
        .namespaced_name = "SVGFEMorphologyElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEMorphologyElementConstructor::initialize,
        .initialize_prototype = &SVGFEMorphologyElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEMorphologyElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEMorphologyElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFEOffsetElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFEOffsetElement"sv,
        .namespaced_name = "SVGFEOffsetElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFEOffsetElementConstructor::initialize,
        .initialize_prototype = &SVGFEOffsetElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFEOffsetElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFEOffsetElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFETurbulenceElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFETurbulenceElement"sv,
        .namespaced_name = "SVGFETurbulenceElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFETurbulenceElementConstructor::initialize,
        .initialize_prototype = &SVGFETurbulenceElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFETurbulenceElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFETurbulenceElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGFilterElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGFilterElement"sv,
        .namespaced_name = "SVGFilterElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGFilterElementConstructor::initialize,
        .initialize_prototype = &SVGFilterElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGFilterElementPrototype::define_unforgeable_attributes,
        .construct = &SVGFilterElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGForeignObjectElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGForeignObjectElement"sv,
        .namespaced_name = "SVGForeignObjectElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGForeignObjectElementConstructor::initialize,
        .initialize_prototype = &SVGForeignObjectElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGForeignObjectElementPrototype::define_unforgeable_attributes,
        .construct = &SVGForeignObjectElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGGElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGGElement"sv,
        .namespaced_name = "SVGGElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGGElementConstructor::initialize,
        .initialize_prototype = &SVGGElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGGElementPrototype::define_unforgeable_attributes,
        .construct = &SVGGElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGGeometryElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGGeometryElement"sv,
        .namespaced_name = "SVGGeometryElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGGeometryElementConstructor::initialize,
        .initialize_prototype = &SVGGeometryElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGGeometryElementPrototype::define_unforgeable_attributes,
        .construct = &SVGGeometryElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGGradientElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGGradientElement"sv,
        .namespaced_name = "SVGGradientElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGGradientElementConstructor::initialize,
        .initialize_prototype = &SVGGradientElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGGradientElementPrototype::define_unforgeable_attributes,
        .construct = &SVGGradientElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGGraphicsElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGGraphicsElement"sv,
        .namespaced_name = "SVGGraphicsElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGGraphicsElementConstructor::initialize,
        .initialize_prototype = &SVGGraphicsElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGGraphicsElementPrototype::define_unforgeable_attributes,
        .construct = &SVGGraphicsElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGImageElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGImageElement"sv,
        .namespaced_name = "SVGImageElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGImageElementConstructor::initialize,
        .initialize_prototype = &SVGImageElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGImageElementPrototype::define_unforgeable_attributes,
        .construct = &SVGImageElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGLengthPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGLength"sv,
        .namespaced_name = "SVGLength"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGLengthConstructor::initialize,
        .initialize_prototype = &SVGLengthPrototype::initialize,
        .define_unforgeable_attributes = &SVGLengthPrototype::define_unforgeable_attributes,
        .construct = &SVGLengthConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGLengthListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGLengthList"sv,
        .namespaced_name = "SVGLengthList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGLengthListConstructor::initialize,
        .construct = &SVGLengthListConstructor::construct,
    };

    auto prototype = realm.create<SVGLengthListPrototype>(realm);
    m_prototypes.set("SVGLengthList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGLinearGradientElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGLinearGradientElement"sv,
        .namespaced_name = "SVGLinearGradientElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGradientElementPrototype>(realm, "SVGGradientElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGradientElementPrototype>(realm, "SVGGradientElement"_fly_string); },
        .initialize_constructor = &SVGLinearGradientElementConstructor::initialize,
        .initialize_prototype = &SVGLinearGradientElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGLinearGradientElementPrototype::define_unforgeable_attributes,
        .construct = &SVGLinearGradientElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGLineElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGLineElement"sv,
        .namespaced_name = "SVGLineElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGLineElementConstructor::initialize,
        .initialize_prototype = &SVGLineElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGLineElementPrototype::define_unforgeable_attributes,
        .construct = &SVGLineElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGMaskElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGMaskElement"sv,
        .namespaced_name = "SVGMaskElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGMaskElementConstructor::initialize,
        .initialize_prototype = &SVGMaskElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGMaskElementPrototype::define_unforgeable_attributes,
        .construct = &SVGMaskElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGMetadataElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGMetadataElement"sv,
        .namespaced_name = "SVGMetadataElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGMetadataElementConstructor::initialize,
        .initialize_prototype = &SVGMetadataElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGMetadataElementPrototype::define_unforgeable_attributes,
        .construct = &SVGMetadataElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGNumberPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGNumber"sv,
        .namespaced_name = "SVGNumber"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGNumberConstructor::initialize,
        .initialize_prototype = &SVGNumberPrototype::initialize,
        .define_unforgeable_attributes = &SVGNumberPrototype::define_unforgeable_attributes,
        .construct = &SVGNumberConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGNumberListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGNumberList"sv,
        .namespaced_name = "SVGNumberList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGNumberListConstructor::initialize,
        .construct = &SVGNumberListConstructor::construct,
    };

    auto prototype = realm.create<SVGNumberListPrototype>(realm);
    m_prototypes.set("SVGNumberList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGPathElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGPathElement"sv,
        .namespaced_name = "SVGPathElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGPathElementConstructor::initialize,
        .initialize_prototype = &SVGPathElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGPathElementPrototype::define_unforgeable_attributes,
        .construct = &SVGPathElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGPatternElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGPatternElement"sv,
        .namespaced_name = "SVGPatternElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGPatternElementConstructor::initialize,
        .initialize_prototype = &SVGPatternElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGPatternElementPrototype::define_unforgeable_attributes,
        .construct = &SVGPatternElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGPolygonElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGPolygonElement"sv,
        .namespaced_name = "SVGPolygonElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGPolygonElementConstructor::initialize,
        .initialize_prototype = &SVGPolygonElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGPolygonElementPrototype::define_unforgeable_attributes,
        .construct = &SVGPolygonElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGPolylineElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGPolylineElement"sv,
        .namespaced_name = "SVGPolylineElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGPolylineElementConstructor::initialize,
        .initialize_prototype = &SVGPolylineElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGPolylineElementPrototype::define_unforgeable_attributes,
        .construct = &SVGPolylineElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGRadialGradientElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGRadialGradientElement"sv,
        .namespaced_name = "SVGRadialGradientElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGradientElementPrototype>(realm, "SVGGradientElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGradientElementPrototype>(realm, "SVGGradientElement"_fly_string); },
        .initialize_constructor = &SVGRadialGradientElementConstructor::initialize,
        .initialize_prototype = &SVGRadialGradientElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGRadialGradientElementPrototype::define_unforgeable_attributes,
        .construct = &SVGRadialGradientElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGRectElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGRectElement"sv,
        .namespaced_name = "SVGRectElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGeometryElementPrototype>(realm, "SVGGeometryElement"_fly_string); },
        .initialize_constructor = &SVGRectElementConstructor::initialize,
        .initialize_prototype = &SVGRectElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGRectElementPrototype::define_unforgeable_attributes,
        .construct = &SVGRectElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGScriptElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGScriptElement"sv,
        .namespaced_name = "SVGScriptElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGScriptElementConstructor::initialize,
        .initialize_prototype = &SVGScriptElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGScriptElementPrototype::define_unforgeable_attributes,
        .construct = &SVGScriptElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGStopElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGStopElement"sv,
        .namespaced_name = "SVGStopElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGStopElementConstructor::initialize,
        .initialize_prototype = &SVGStopElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGStopElementPrototype::define_unforgeable_attributes,
        .construct = &SVGStopElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGStyleElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGStyleElement"sv,
        .namespaced_name = "SVGStyleElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGStyleElementConstructor::initialize,
        .initialize_prototype = &SVGStyleElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGStyleElementPrototype::define_unforgeable_attributes,
        .construct = &SVGStyleElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGSVGElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGSVGElement"sv,
        .namespaced_name = "SVGSVGElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGSVGElementConstructor::initialize,
        .initialize_prototype = &SVGSVGElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGSVGElementPrototype::define_unforgeable_attributes,
        .construct = &SVGSVGElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGSymbolElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGSymbolElement"sv,
        .namespaced_name = "SVGSymbolElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGSymbolElementConstructor::initialize,
        .initialize_prototype = &SVGSymbolElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGSymbolElementPrototype::define_unforgeable_attributes,
        .construct = &SVGSymbolElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTextContentElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTextContentElement"sv,
        .namespaced_name = "SVGTextContentElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGTextContentElementConstructor::initialize,
        .initialize_prototype = &SVGTextContentElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTextContentElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTextContentElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTextElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTextElement"sv,
        .namespaced_name = "SVGTextElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGTextPositioningElementPrototype>(realm, "SVGTextPositioningElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGTextPositioningElementPrototype>(realm, "SVGTextPositioningElement"_fly_string); },
        .initialize_constructor = &SVGTextElementConstructor::initialize,
        .initialize_prototype = &SVGTextElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTextElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTextElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTextPathElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTextPathElement"sv,
        .namespaced_name = "SVGTextPathElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGTextContentElementPrototype>(realm, "SVGTextContentElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGTextContentElementPrototype>(realm, "SVGTextContentElement"_fly_string); },
        .initialize_constructor = &SVGTextPathElementConstructor::initialize,
        .initialize_prototype = &SVGTextPathElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTextPathElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTextPathElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTextPositioningElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTextPositioningElement"sv,
        .namespaced_name = "SVGTextPositioningElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGTextContentElementPrototype>(realm, "SVGTextContentElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGTextContentElementPrototype>(realm, "SVGTextContentElement"_fly_string); },
        .initialize_constructor = &SVGTextPositioningElementConstructor::initialize,
        .initialize_prototype = &SVGTextPositioningElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTextPositioningElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTextPositioningElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTitleElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTitleElement"sv,
        .namespaced_name = "SVGTitleElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGTitleElementConstructor::initialize,
        .initialize_prototype = &SVGTitleElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTitleElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTitleElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTransformPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTransform"sv,
        .namespaced_name = "SVGTransform"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGTransformConstructor::initialize,
        .initialize_prototype = &SVGTransformPrototype::initialize,
        .define_unforgeable_attributes = &SVGTransformPrototype::define_unforgeable_attributes,
        .construct = &SVGTransformConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTransformListPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTransformList"sv,
        .namespaced_name = "SVGTransformList"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGTransformListConstructor::initialize,
        .construct = &SVGTransformListConstructor::construct,
    };

    auto prototype = realm.create<SVGTransformListPrototype>(realm);
    m_prototypes.set("SVGTransformList"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGTSpanElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGTSpanElement"sv,
        .namespaced_name = "SVGTSpanElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGTextPositioningElementPrototype>(realm, "SVGTextPositioningElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGTextPositioningElementPrototype>(realm, "SVGTextPositioningElement"_fly_string); },
        .initialize_constructor = &SVGTSpanElementConstructor::initialize,
        .initialize_prototype = &SVGTSpanElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGTSpanElementPrototype::define_unforgeable_attributes,
        .construct = &SVGTSpanElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGUnitTypesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGUnitTypes"sv,
        .namespaced_name = "SVGUnitTypes"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &SVGUnitTypesConstructor::initialize,
        .initialize_prototype = &SVGUnitTypesPrototype::initialize,
        .define_unforgeable_attributes = &SVGUnitTypesPrototype::define_unforgeable_attributes,
        .construct = &SVGUnitTypesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGUseElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGUseElement"sv,
        .namespaced_name = "SVGUseElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGGraphicsElementPrototype>(realm, "SVGGraphicsElement"_fly_string); },
        .initialize_constructor = &SVGUseElementConstructor::initialize,
        .initialize_prototype = &SVGUseElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGUseElementPrototype::define_unforgeable_attributes,
        .construct = &SVGUseElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<SVGViewElementPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "SVGViewElement"sv,
        .namespaced_name = "SVGViewElement"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<SVGElementPrototype>(realm, "SVGElement"_fly_string); },
        .initialize_constructor = &SVGViewElementConstructor::initialize,
        .initialize_prototype = &SVGViewElementPrototype::initialize,
        .define_unforgeable_attributes = &SVGViewElementPrototype::define_unforgeable_attributes,
        .construct = &SVGViewElementConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrustedHTMLPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrustedHTML"sv,
        .namespaced_name = "TrustedHTML"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TrustedHTMLConstructor::initialize,
        .initialize_prototype = &TrustedHTMLPrototype::initialize,
        .define_unforgeable_attributes = &TrustedHTMLPrototype::define_unforgeable_attributes,
        .construct = &TrustedHTMLConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrustedScriptPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrustedScript"sv,
        .namespaced_name = "TrustedScript"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TrustedScriptConstructor::initialize,
        .initialize_prototype = &TrustedScriptPrototype::initialize,
        .define_unforgeable_attributes = &TrustedScriptPrototype::define_unforgeable_attributes,
        .construct = &TrustedScriptConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrustedScriptURLPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrustedScriptURL"sv,
        .namespaced_name = "TrustedScriptURL"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TrustedScriptURLConstructor::initialize,
        .initialize_prototype = &TrustedScriptURLPrototype::initialize,
        .define_unforgeable_attributes = &TrustedScriptURLPrototype::define_unforgeable_attributes,
        .construct = &TrustedScriptURLConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrustedTypePolicyPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrustedTypePolicy"sv,
        .namespaced_name = "TrustedTypePolicy"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TrustedTypePolicyConstructor::initialize,
        .initialize_prototype = &TrustedTypePolicyPrototype::initialize,
        .define_unforgeable_attributes = &TrustedTypePolicyPrototype::define_unforgeable_attributes,
        .construct = &TrustedTypePolicyConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TrustedTypePolicyFactoryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TrustedTypePolicyFactory"sv,
        .namespaced_name = "TrustedTypePolicyFactory"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TrustedTypePolicyFactoryConstructor::initialize,
        .initialize_prototype = &TrustedTypePolicyFactoryPrototype::initialize,
        .define_unforgeable_attributes = &TrustedTypePolicyFactoryPrototype::define_unforgeable_attributes,
        .construct = &TrustedTypePolicyFactoryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<CompositionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "CompositionEvent"sv,
        .namespaced_name = "CompositionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &CompositionEventConstructor::initialize,
        .initialize_prototype = &CompositionEventPrototype::initialize,
        .define_unforgeable_attributes = &CompositionEventPrototype::define_unforgeable_attributes,
        .construct = &CompositionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FocusEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FocusEvent"sv,
        .namespaced_name = "FocusEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &FocusEventConstructor::initialize,
        .initialize_prototype = &FocusEventPrototype::initialize,
        .define_unforgeable_attributes = &FocusEventPrototype::define_unforgeable_attributes,
        .construct = &FocusEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<InputEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "InputEvent"sv,
        .namespaced_name = "InputEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &InputEventConstructor::initialize,
        .initialize_prototype = &InputEventPrototype::initialize,
        .define_unforgeable_attributes = &InputEventPrototype::define_unforgeable_attributes,
        .construct = &InputEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<KeyboardEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "KeyboardEvent"sv,
        .namespaced_name = "KeyboardEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &KeyboardEventConstructor::initialize,
        .initialize_prototype = &KeyboardEventPrototype::initialize,
        .define_unforgeable_attributes = &KeyboardEventPrototype::define_unforgeable_attributes,
        .construct = &KeyboardEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MouseEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MouseEvent"sv,
        .namespaced_name = "MouseEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &MouseEventConstructor::initialize,
        .initialize_prototype = &MouseEventPrototype::initialize,
        .define_unforgeable_attributes = &MouseEventPrototype::define_unforgeable_attributes,
        .construct = &MouseEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PointerEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PointerEvent"sv,
        .namespaced_name = "PointerEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .initialize_constructor = &PointerEventConstructor::initialize,
        .initialize_prototype = &PointerEventPrototype::initialize,
        .define_unforgeable_attributes = &PointerEventPrototype::define_unforgeable_attributes,
        .construct = &PointerEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TextEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "TextEvent"sv,
        .namespaced_name = "TextEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<UIEventPrototype>(realm, "UIEvent"_fly_string); },
        .initialize_constructor = &TextEventConstructor::initialize,
        .initialize_prototype = &TextEventPrototype::initialize,
        .define_unforgeable_attributes = &TextEventPrototype::define_unforgeable_attributes,
        .construct = &TextEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<UIEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "UIEvent"sv,
        .namespaced_name = "UIEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &UIEventConstructor::initialize,
        .initialize_prototype = &UIEventPrototype::initialize,
        .define_unforgeable_attributes = &UIEventPrototype::define_unforgeable_attributes,
        .construct = &UIEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WheelEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WheelEvent"sv,
        .namespaced_name = "WheelEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<MouseEventPrototype>(realm, "MouseEvent"_fly_string); },
        .initialize_constructor = &WheelEventConstructor::initialize,
        .initialize_prototype = &WheelEventPrototype::initialize,
        .define_unforgeable_attributes = &WheelEventPrototype::define_unforgeable_attributes,
        .construct = &WheelEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<URLPatternPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "URLPattern"sv,
        .namespaced_name = "URLPattern"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &URLPatternConstructor::initialize,
        .initialize_prototype = &URLPatternPrototype::initialize,
        .define_unforgeable_attributes = &URLPatternPrototype::define_unforgeable_attributes,
        .construct = &URLPatternConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceMarkPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceMark"sv,
        .namespaced_name = "PerformanceMark"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .initialize_constructor = &PerformanceMarkConstructor::initialize,
        .initialize_prototype = &PerformanceMarkPrototype::initialize,
        .define_unforgeable_attributes = &PerformanceMarkPrototype::define_unforgeable_attributes,
        .construct = &PerformanceMarkConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PerformanceMeasurePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PerformanceMeasure"sv,
        .namespaced_name = "PerformanceMeasure"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<PerformanceEntryPrototype>(realm, "PerformanceEntry"_fly_string); },
        .initialize_constructor = &PerformanceMeasureConstructor::initialize,
        .initialize_prototype = &PerformanceMeasurePrototype::initialize,
        .define_unforgeable_attributes = &PerformanceMeasurePrototype::define_unforgeable_attributes,
        .construct = &PerformanceMeasureConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ViewTransitionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ViewTransition"sv,
        .namespaced_name = "ViewTransition"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ViewTransitionConstructor::initialize,
        .initialize_prototype = &ViewTransitionPrototype::initialize,
        .define_unforgeable_attributes = &ViewTransitionPrototype::define_unforgeable_attributes,
        .construct = &ViewTransitionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GlobalPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Global"sv,
        .namespaced_name = "WebAssembly.Global"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &GlobalConstructor::initialize,
        .initialize_prototype = &GlobalPrototype::initialize,
        .define_unforgeable_attributes = &GlobalPrototype::define_unforgeable_attributes,
        .construct = &GlobalConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<InstancePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Instance"sv,
        .namespaced_name = "WebAssembly.Instance"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &InstanceConstructor::initialize,
        .initialize_prototype = &InstancePrototype::initialize,
        .define_unforgeable_attributes = &InstancePrototype::define_unforgeable_attributes,
        .construct = &InstanceConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MemoryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Memory"sv,
        .namespaced_name = "WebAssembly.Memory"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &MemoryConstructor::initialize,
        .initialize_prototype = &MemoryPrototype::initialize,
        .define_unforgeable_attributes = &MemoryPrototype::define_unforgeable_attributes,
        .construct = &MemoryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ModulePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Module"sv,
        .namespaced_name = "WebAssembly.Module"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ModuleConstructor::initialize,
        .initialize_prototype = &ModulePrototype::initialize,
        .define_unforgeable_attributes = &ModulePrototype::define_unforgeable_attributes,
        .construct = &ModuleConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<TablePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "Table"sv,
        .namespaced_name = "WebAssembly.Table"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &TableConstructor::initialize,
        .initialize_prototype = &TablePrototype::initialize,
        .define_unforgeable_attributes = &TablePrototype::define_unforgeable_attributes,
        .construct = &TableConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
void Intrinsics::create_web_namespace<WebAssemblyNamespace>(JS::Realm& realm)
{
    auto namespace_object = realm.create<WebAssemblyNamespace>(realm);
    m_namespaces.set("WebAssembly"_fly_string, namespace_object);

    [[maybe_unused]] static constexpr u8 attr = JS::Attribute::Writable | JS::Attribute::Configurable;
    namespace_object->define_intrinsic_accessor("Global"_utf16_fly_string, attr, [](auto& realm) -> JS::Value { return &Bindings::ensure_web_constructor<GlobalPrototype>(realm, "WebAssembly.Global"_fly_string); });
    namespace_object->define_intrinsic_accessor("Instance"_utf16_fly_string, attr, [](auto& realm) -> JS::Value { return &Bindings::ensure_web_constructor<InstancePrototype>(realm, "WebAssembly.Instance"_fly_string); });
    namespace_object->define_intrinsic_accessor("Memory"_utf16_fly_string, attr, [](auto& realm) -> JS::Value { return &Bindings::ensure_web_constructor<MemoryPrototype>(realm, "WebAssembly.Memory"_fly_string); });
    namespace_object->define_intrinsic_accessor("Module"_utf16_fly_string, attr, [](auto& realm) -> JS::Value { return &Bindings::ensure_web_constructor<ModulePrototype>(realm, "WebAssembly.Module"_fly_string); });
    namespace_object->define_intrinsic_accessor("Table"_utf16_fly_string, attr, [](auto& realm) -> JS::Value { return &Bindings::ensure_web_constructor<TablePrototype>(realm, "WebAssembly.Table"_fly_string); });
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AnalyserNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AnalyserNode"sv,
        .namespaced_name = "AnalyserNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &AnalyserNodeConstructor::initialize,
        .initialize_prototype = &AnalyserNodePrototype::initialize,
        .define_unforgeable_attributes = &AnalyserNodePrototype::define_unforgeable_attributes,
        .construct = &AnalyserNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioBufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioBuffer"sv,
        .namespaced_name = "AudioBuffer"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AudioBufferConstructor::initialize,
        .initialize_prototype = &AudioBufferPrototype::initialize,
        .define_unforgeable_attributes = &AudioBufferPrototype::define_unforgeable_attributes,
        .construct = &AudioBufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioBufferSourceNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioBufferSourceNode"sv,
        .namespaced_name = "AudioBufferSourceNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .initialize_constructor = &AudioBufferSourceNodeConstructor::initialize,
        .initialize_prototype = &AudioBufferSourceNodePrototype::initialize,
        .define_unforgeable_attributes = &AudioBufferSourceNodePrototype::define_unforgeable_attributes,
        .construct = &AudioBufferSourceNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioContextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioContext"sv,
        .namespaced_name = "AudioContext"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<BaseAudioContextPrototype>(realm, "BaseAudioContext"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<BaseAudioContextPrototype>(realm, "BaseAudioContext"_fly_string); },
        .initialize_constructor = &AudioContextConstructor::initialize,
        .initialize_prototype = &AudioContextPrototype::initialize,
        .define_unforgeable_attributes = &AudioContextPrototype::define_unforgeable_attributes,
        .construct = &AudioContextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioDestinationNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioDestinationNode"sv,
        .namespaced_name = "AudioDestinationNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &AudioDestinationNodeConstructor::initialize,
        .initialize_prototype = &AudioDestinationNodePrototype::initialize,
        .define_unforgeable_attributes = &AudioDestinationNodePrototype::define_unforgeable_attributes,
        .construct = &AudioDestinationNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioListenerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioListener"sv,
        .namespaced_name = "AudioListener"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AudioListenerConstructor::initialize,
        .initialize_prototype = &AudioListenerPrototype::initialize,
        .define_unforgeable_attributes = &AudioListenerPrototype::define_unforgeable_attributes,
        .construct = &AudioListenerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioNode"sv,
        .namespaced_name = "AudioNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &AudioNodeConstructor::initialize,
        .initialize_prototype = &AudioNodePrototype::initialize,
        .define_unforgeable_attributes = &AudioNodePrototype::define_unforgeable_attributes,
        .construct = &AudioNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioParamPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioParam"sv,
        .namespaced_name = "AudioParam"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &AudioParamConstructor::initialize,
        .initialize_prototype = &AudioParamPrototype::initialize,
        .define_unforgeable_attributes = &AudioParamPrototype::define_unforgeable_attributes,
        .construct = &AudioParamConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<AudioScheduledSourceNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "AudioScheduledSourceNode"sv,
        .namespaced_name = "AudioScheduledSourceNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &AudioScheduledSourceNodeConstructor::initialize,
        .initialize_prototype = &AudioScheduledSourceNodePrototype::initialize,
        .define_unforgeable_attributes = &AudioScheduledSourceNodePrototype::define_unforgeable_attributes,
        .construct = &AudioScheduledSourceNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BaseAudioContextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BaseAudioContext"sv,
        .namespaced_name = "BaseAudioContext"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &BaseAudioContextConstructor::initialize,
        .initialize_prototype = &BaseAudioContextPrototype::initialize,
        .define_unforgeable_attributes = &BaseAudioContextPrototype::define_unforgeable_attributes,
        .construct = &BaseAudioContextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<BiquadFilterNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "BiquadFilterNode"sv,
        .namespaced_name = "BiquadFilterNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &BiquadFilterNodeConstructor::initialize,
        .initialize_prototype = &BiquadFilterNodePrototype::initialize,
        .define_unforgeable_attributes = &BiquadFilterNodePrototype::define_unforgeable_attributes,
        .construct = &BiquadFilterNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ChannelMergerNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ChannelMergerNode"sv,
        .namespaced_name = "ChannelMergerNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &ChannelMergerNodeConstructor::initialize,
        .initialize_prototype = &ChannelMergerNodePrototype::initialize,
        .define_unforgeable_attributes = &ChannelMergerNodePrototype::define_unforgeable_attributes,
        .construct = &ChannelMergerNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ChannelSplitterNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ChannelSplitterNode"sv,
        .namespaced_name = "ChannelSplitterNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &ChannelSplitterNodeConstructor::initialize,
        .initialize_prototype = &ChannelSplitterNodePrototype::initialize,
        .define_unforgeable_attributes = &ChannelSplitterNodePrototype::define_unforgeable_attributes,
        .construct = &ChannelSplitterNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ConstantSourceNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ConstantSourceNode"sv,
        .namespaced_name = "ConstantSourceNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .initialize_constructor = &ConstantSourceNodeConstructor::initialize,
        .initialize_prototype = &ConstantSourceNodePrototype::initialize,
        .define_unforgeable_attributes = &ConstantSourceNodePrototype::define_unforgeable_attributes,
        .construct = &ConstantSourceNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DelayNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DelayNode"sv,
        .namespaced_name = "DelayNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &DelayNodeConstructor::initialize,
        .initialize_prototype = &DelayNodePrototype::initialize,
        .define_unforgeable_attributes = &DelayNodePrototype::define_unforgeable_attributes,
        .construct = &DelayNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DynamicsCompressorNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DynamicsCompressorNode"sv,
        .namespaced_name = "DynamicsCompressorNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &DynamicsCompressorNodeConstructor::initialize,
        .initialize_prototype = &DynamicsCompressorNodePrototype::initialize,
        .define_unforgeable_attributes = &DynamicsCompressorNodePrototype::define_unforgeable_attributes,
        .construct = &DynamicsCompressorNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<GainNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "GainNode"sv,
        .namespaced_name = "GainNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &GainNodeConstructor::initialize,
        .initialize_prototype = &GainNodePrototype::initialize,
        .define_unforgeable_attributes = &GainNodePrototype::define_unforgeable_attributes,
        .construct = &GainNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<MediaElementAudioSourceNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "MediaElementAudioSourceNode"sv,
        .namespaced_name = "MediaElementAudioSourceNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &MediaElementAudioSourceNodeConstructor::initialize,
        .initialize_prototype = &MediaElementAudioSourceNodePrototype::initialize,
        .define_unforgeable_attributes = &MediaElementAudioSourceNodePrototype::define_unforgeable_attributes,
        .construct = &MediaElementAudioSourceNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OfflineAudioCompletionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OfflineAudioCompletionEvent"sv,
        .namespaced_name = "OfflineAudioCompletionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &OfflineAudioCompletionEventConstructor::initialize,
        .initialize_prototype = &OfflineAudioCompletionEventPrototype::initialize,
        .define_unforgeable_attributes = &OfflineAudioCompletionEventPrototype::define_unforgeable_attributes,
        .construct = &OfflineAudioCompletionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OfflineAudioContextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OfflineAudioContext"sv,
        .namespaced_name = "OfflineAudioContext"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<BaseAudioContextPrototype>(realm, "BaseAudioContext"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<BaseAudioContextPrototype>(realm, "BaseAudioContext"_fly_string); },
        .initialize_constructor = &OfflineAudioContextConstructor::initialize,
        .initialize_prototype = &OfflineAudioContextPrototype::initialize,
        .define_unforgeable_attributes = &OfflineAudioContextPrototype::define_unforgeable_attributes,
        .construct = &OfflineAudioContextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OscillatorNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OscillatorNode"sv,
        .namespaced_name = "OscillatorNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioScheduledSourceNodePrototype>(realm, "AudioScheduledSourceNode"_fly_string); },
        .initialize_constructor = &OscillatorNodeConstructor::initialize,
        .initialize_prototype = &OscillatorNodePrototype::initialize,
        .define_unforgeable_attributes = &OscillatorNodePrototype::define_unforgeable_attributes,
        .construct = &OscillatorNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PannerNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PannerNode"sv,
        .namespaced_name = "PannerNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &PannerNodeConstructor::initialize,
        .initialize_prototype = &PannerNodePrototype::initialize,
        .define_unforgeable_attributes = &PannerNodePrototype::define_unforgeable_attributes,
        .construct = &PannerNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<PeriodicWavePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "PeriodicWave"sv,
        .namespaced_name = "PeriodicWave"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &PeriodicWaveConstructor::initialize,
        .initialize_prototype = &PeriodicWavePrototype::initialize,
        .define_unforgeable_attributes = &PeriodicWavePrototype::define_unforgeable_attributes,
        .construct = &PeriodicWaveConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ScriptProcessorNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ScriptProcessorNode"sv,
        .namespaced_name = "ScriptProcessorNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &ScriptProcessorNodeConstructor::initialize,
        .initialize_prototype = &ScriptProcessorNodePrototype::initialize,
        .define_unforgeable_attributes = &ScriptProcessorNodePrototype::define_unforgeable_attributes,
        .construct = &ScriptProcessorNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<StereoPannerNodePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "StereoPannerNode"sv,
        .namespaced_name = "StereoPannerNode"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<AudioNodePrototype>(realm, "AudioNode"_fly_string); },
        .initialize_constructor = &StereoPannerNodeConstructor::initialize,
        .initialize_prototype = &StereoPannerNodePrototype::initialize,
        .define_unforgeable_attributes = &StereoPannerNodePrototype::define_unforgeable_attributes,
        .construct = &StereoPannerNodeConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ANGLEInstancedArraysPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ANGLEInstancedArrays"sv,
        .namespaced_name = "ANGLEInstancedArrays"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &ANGLEInstancedArraysConstructor::initialize,
        .initialize_prototype = &ANGLEInstancedArraysPrototype::initialize,
        .define_unforgeable_attributes = &ANGLEInstancedArraysPrototype::define_unforgeable_attributes,
        .construct = &ANGLEInstancedArraysConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EXTBlendMinMaxPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EXTBlendMinMax"sv,
        .namespaced_name = "EXTBlendMinMax"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EXTBlendMinMaxConstructor::initialize,
        .initialize_prototype = &EXTBlendMinMaxPrototype::initialize,
        .define_unforgeable_attributes = &EXTBlendMinMaxPrototype::define_unforgeable_attributes,
        .construct = &EXTBlendMinMaxConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EXTColorBufferFloatPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EXTColorBufferFloat"sv,
        .namespaced_name = "EXTColorBufferFloat"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EXTColorBufferFloatConstructor::initialize,
        .initialize_prototype = &EXTColorBufferFloatPrototype::initialize,
        .define_unforgeable_attributes = &EXTColorBufferFloatPrototype::define_unforgeable_attributes,
        .construct = &EXTColorBufferFloatConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EXTRenderSnormPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EXTRenderSnorm"sv,
        .namespaced_name = "EXTRenderSnorm"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EXTRenderSnormConstructor::initialize,
        .initialize_prototype = &EXTRenderSnormPrototype::initialize,
        .define_unforgeable_attributes = &EXTRenderSnormPrototype::define_unforgeable_attributes,
        .construct = &EXTRenderSnormConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EXTTextureFilterAnisotropicPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EXTTextureFilterAnisotropic"sv,
        .namespaced_name = "EXTTextureFilterAnisotropic"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EXTTextureFilterAnisotropicConstructor::initialize,
        .initialize_prototype = &EXTTextureFilterAnisotropicPrototype::initialize,
        .define_unforgeable_attributes = &EXTTextureFilterAnisotropicPrototype::define_unforgeable_attributes,
        .construct = &EXTTextureFilterAnisotropicConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<EXTTextureNorm16Prototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "EXTTextureNorm16"sv,
        .namespaced_name = "EXTTextureNorm16"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &EXTTextureNorm16Constructor::initialize,
        .initialize_prototype = &EXTTextureNorm16Prototype::initialize,
        .define_unforgeable_attributes = &EXTTextureNorm16Prototype::define_unforgeable_attributes,
        .construct = &EXTTextureNorm16Constructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OESElementIndexUintPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OESElementIndexUint"sv,
        .namespaced_name = "OESElementIndexUint"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &OESElementIndexUintConstructor::initialize,
        .initialize_prototype = &OESElementIndexUintPrototype::initialize,
        .define_unforgeable_attributes = &OESElementIndexUintPrototype::define_unforgeable_attributes,
        .construct = &OESElementIndexUintConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OESStandardDerivativesPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OESStandardDerivatives"sv,
        .namespaced_name = "OESStandardDerivatives"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &OESStandardDerivativesConstructor::initialize,
        .initialize_prototype = &OESStandardDerivativesPrototype::initialize,
        .define_unforgeable_attributes = &OESStandardDerivativesPrototype::define_unforgeable_attributes,
        .construct = &OESStandardDerivativesConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<OESVertexArrayObjectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "OESVertexArrayObject"sv,
        .namespaced_name = "OESVertexArrayObject"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &OESVertexArrayObjectConstructor::initialize,
        .initialize_prototype = &OESVertexArrayObjectPrototype::initialize,
        .define_unforgeable_attributes = &OESVertexArrayObjectPrototype::define_unforgeable_attributes,
        .construct = &OESVertexArrayObjectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLCompressedTextureS3tcPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLCompressedTextureS3tc"sv,
        .namespaced_name = "WebGLCompressedTextureS3tc"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLCompressedTextureS3tcConstructor::initialize,
        .initialize_prototype = &WebGLCompressedTextureS3tcPrototype::initialize,
        .define_unforgeable_attributes = &WebGLCompressedTextureS3tcPrototype::define_unforgeable_attributes,
        .construct = &WebGLCompressedTextureS3tcConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLCompressedTextureS3tcSrgbPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLCompressedTextureS3tcSrgb"sv,
        .namespaced_name = "WebGLCompressedTextureS3tcSrgb"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLCompressedTextureS3tcSrgbConstructor::initialize,
        .initialize_prototype = &WebGLCompressedTextureS3tcSrgbPrototype::initialize,
        .define_unforgeable_attributes = &WebGLCompressedTextureS3tcSrgbPrototype::define_unforgeable_attributes,
        .construct = &WebGLCompressedTextureS3tcSrgbConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLDebugRendererInfoPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLDebugRendererInfo"sv,
        .namespaced_name = "WebGLDebugRendererInfo"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLDebugRendererInfoConstructor::initialize,
        .initialize_prototype = &WebGLDebugRendererInfoPrototype::initialize,
        .define_unforgeable_attributes = &WebGLDebugRendererInfoPrototype::define_unforgeable_attributes,
        .construct = &WebGLDebugRendererInfoConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLDrawBuffersPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLDrawBuffers"sv,
        .namespaced_name = "WebGLDrawBuffers"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLDrawBuffersConstructor::initialize,
        .initialize_prototype = &WebGLDrawBuffersPrototype::initialize,
        .define_unforgeable_attributes = &WebGLDrawBuffersPrototype::define_unforgeable_attributes,
        .construct = &WebGLDrawBuffersConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLVertexArrayObjectOESPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLVertexArrayObjectOES"sv,
        .namespaced_name = "WebGLVertexArrayObjectOES"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLVertexArrayObjectOESConstructor::initialize,
        .initialize_prototype = &WebGLVertexArrayObjectOESPrototype::initialize,
        .define_unforgeable_attributes = &WebGLVertexArrayObjectOESPrototype::define_unforgeable_attributes,
        .construct = &WebGLVertexArrayObjectOESConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGL2RenderingContextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGL2RenderingContext"sv,
        .namespaced_name = "WebGL2RenderingContext"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGL2RenderingContextConstructor::initialize,
        .initialize_prototype = &WebGL2RenderingContextPrototype::initialize,
        .define_unforgeable_attributes = &WebGL2RenderingContextPrototype::define_unforgeable_attributes,
        .construct = &WebGL2RenderingContextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLActiveInfoPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLActiveInfo"sv,
        .namespaced_name = "WebGLActiveInfo"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLActiveInfoConstructor::initialize,
        .initialize_prototype = &WebGLActiveInfoPrototype::initialize,
        .define_unforgeable_attributes = &WebGLActiveInfoPrototype::define_unforgeable_attributes,
        .construct = &WebGLActiveInfoConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLBufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLBuffer"sv,
        .namespaced_name = "WebGLBuffer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLBufferConstructor::initialize,
        .initialize_prototype = &WebGLBufferPrototype::initialize,
        .define_unforgeable_attributes = &WebGLBufferPrototype::define_unforgeable_attributes,
        .construct = &WebGLBufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLContextEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLContextEvent"sv,
        .namespaced_name = "WebGLContextEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &WebGLContextEventConstructor::initialize,
        .initialize_prototype = &WebGLContextEventPrototype::initialize,
        .define_unforgeable_attributes = &WebGLContextEventPrototype::define_unforgeable_attributes,
        .construct = &WebGLContextEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLFramebufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLFramebuffer"sv,
        .namespaced_name = "WebGLFramebuffer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLFramebufferConstructor::initialize,
        .initialize_prototype = &WebGLFramebufferPrototype::initialize,
        .define_unforgeable_attributes = &WebGLFramebufferPrototype::define_unforgeable_attributes,
        .construct = &WebGLFramebufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLObjectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLObject"sv,
        .namespaced_name = "WebGLObject"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLObjectConstructor::initialize,
        .initialize_prototype = &WebGLObjectPrototype::initialize,
        .define_unforgeable_attributes = &WebGLObjectPrototype::define_unforgeable_attributes,
        .construct = &WebGLObjectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLProgramPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLProgram"sv,
        .namespaced_name = "WebGLProgram"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLProgramConstructor::initialize,
        .initialize_prototype = &WebGLProgramPrototype::initialize,
        .define_unforgeable_attributes = &WebGLProgramPrototype::define_unforgeable_attributes,
        .construct = &WebGLProgramConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLQueryPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLQuery"sv,
        .namespaced_name = "WebGLQuery"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLQueryConstructor::initialize,
        .initialize_prototype = &WebGLQueryPrototype::initialize,
        .define_unforgeable_attributes = &WebGLQueryPrototype::define_unforgeable_attributes,
        .construct = &WebGLQueryConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLRenderbufferPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLRenderbuffer"sv,
        .namespaced_name = "WebGLRenderbuffer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLRenderbufferConstructor::initialize,
        .initialize_prototype = &WebGLRenderbufferPrototype::initialize,
        .define_unforgeable_attributes = &WebGLRenderbufferPrototype::define_unforgeable_attributes,
        .construct = &WebGLRenderbufferConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLRenderingContextPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLRenderingContext"sv,
        .namespaced_name = "WebGLRenderingContext"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLRenderingContextConstructor::initialize,
        .initialize_prototype = &WebGLRenderingContextPrototype::initialize,
        .define_unforgeable_attributes = &WebGLRenderingContextPrototype::define_unforgeable_attributes,
        .construct = &WebGLRenderingContextConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLSamplerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLSampler"sv,
        .namespaced_name = "WebGLSampler"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLSamplerConstructor::initialize,
        .initialize_prototype = &WebGLSamplerPrototype::initialize,
        .define_unforgeable_attributes = &WebGLSamplerPrototype::define_unforgeable_attributes,
        .construct = &WebGLSamplerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLShaderPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLShader"sv,
        .namespaced_name = "WebGLShader"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLShaderConstructor::initialize,
        .initialize_prototype = &WebGLShaderPrototype::initialize,
        .define_unforgeable_attributes = &WebGLShaderPrototype::define_unforgeable_attributes,
        .construct = &WebGLShaderConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLShaderPrecisionFormatPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLShaderPrecisionFormat"sv,
        .namespaced_name = "WebGLShaderPrecisionFormat"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLShaderPrecisionFormatConstructor::initialize,
        .initialize_prototype = &WebGLShaderPrecisionFormatPrototype::initialize,
        .define_unforgeable_attributes = &WebGLShaderPrecisionFormatPrototype::define_unforgeable_attributes,
        .construct = &WebGLShaderPrecisionFormatConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLSyncPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLSync"sv,
        .namespaced_name = "WebGLSync"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLSyncConstructor::initialize,
        .initialize_prototype = &WebGLSyncPrototype::initialize,
        .define_unforgeable_attributes = &WebGLSyncPrototype::define_unforgeable_attributes,
        .construct = &WebGLSyncConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLTexturePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLTexture"sv,
        .namespaced_name = "WebGLTexture"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLTextureConstructor::initialize,
        .initialize_prototype = &WebGLTexturePrototype::initialize,
        .define_unforgeable_attributes = &WebGLTexturePrototype::define_unforgeable_attributes,
        .construct = &WebGLTextureConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLTransformFeedbackPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLTransformFeedback"sv,
        .namespaced_name = "WebGLTransformFeedback"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLTransformFeedbackConstructor::initialize,
        .initialize_prototype = &WebGLTransformFeedbackPrototype::initialize,
        .define_unforgeable_attributes = &WebGLTransformFeedbackPrototype::define_unforgeable_attributes,
        .construct = &WebGLTransformFeedbackConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLUniformLocationPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLUniformLocation"sv,
        .namespaced_name = "WebGLUniformLocation"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &WebGLUniformLocationConstructor::initialize,
        .initialize_prototype = &WebGLUniformLocationPrototype::initialize,
        .define_unforgeable_attributes = &WebGLUniformLocationPrototype::define_unforgeable_attributes,
        .construct = &WebGLUniformLocationConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebGLVertexArrayObjectPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebGLVertexArrayObject"sv,
        .namespaced_name = "WebGLVertexArrayObject"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<WebGLObjectPrototype>(realm, "WebGLObject"_fly_string); },
        .initialize_constructor = &WebGLVertexArrayObjectConstructor::initialize,
        .initialize_prototype = &WebGLVertexArrayObjectPrototype::initialize,
        .define_unforgeable_attributes = &WebGLVertexArrayObjectPrototype::define_unforgeable_attributes,
        .construct = &WebGLVertexArrayObjectConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<DOMExceptionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "DOMException"sv,
        .namespaced_name = "DOMException"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &DOMExceptionConstructor::initialize,
        .initialize_prototype = &DOMExceptionPrototype::initialize,
        .define_unforgeable_attributes = &DOMExceptionPrototype::define_unforgeable_attributes,
        .construct = &DOMExceptionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<QuotaExceededErrorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "QuotaExceededError"sv,
        .namespaced_name = "QuotaExceededError"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<DOMExceptionPrototype>(realm, "DOMException"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<DOMExceptionPrototype>(realm, "DOMException"_fly_string); },
        .initialize_constructor = &QuotaExceededErrorConstructor::initialize,
        .initialize_prototype = &QuotaExceededErrorPrototype::initialize,
        .define_unforgeable_attributes = &QuotaExceededErrorPrototype::define_unforgeable_attributes,
        .construct = &QuotaExceededErrorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<WebSocketPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "WebSocket"sv,
        .namespaced_name = "WebSocket"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &WebSocketConstructor::initialize,
        .initialize_prototype = &WebSocketPrototype::initialize,
        .define_unforgeable_attributes = &WebSocketPrototype::define_unforgeable_attributes,
        .construct = &WebSocketConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<VTTCuePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "VTTCue"sv,
        .namespaced_name = "VTTCue"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<TextTrackCuePrototype>(realm, "TextTrackCue"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<TextTrackCuePrototype>(realm, "TextTrackCue"_fly_string); },
        .initialize_constructor = &VTTCueConstructor::initialize,
        .initialize_prototype = &VTTCuePrototype::initialize,
        .define_unforgeable_attributes = &VTTCuePrototype::define_unforgeable_attributes,
        .construct = &VTTCueConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<VTTRegionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "VTTRegion"sv,
        .namespaced_name = "VTTRegion"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &VTTRegionConstructor::initialize,
        .initialize_prototype = &VTTRegionPrototype::initialize,
        .define_unforgeable_attributes = &VTTRegionPrototype::define_unforgeable_attributes,
        .construct = &VTTRegionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRLayerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRLayer"sv,
        .namespaced_name = "XRLayer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &XRLayerConstructor::initialize,
        .initialize_prototype = &XRLayerPrototype::initialize,
        .define_unforgeable_attributes = &XRLayerPrototype::define_unforgeable_attributes,
        .construct = &XRLayerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRRenderStatePrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRRenderState"sv,
        .namespaced_name = "XRRenderState"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XRRenderStateConstructor::initialize,
        .initialize_prototype = &XRRenderStatePrototype::initialize,
        .define_unforgeable_attributes = &XRRenderStatePrototype::define_unforgeable_attributes,
        .construct = &XRRenderStateConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRSessionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRSession"sv,
        .namespaced_name = "XRSession"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &XRSessionConstructor::initialize,
        .initialize_prototype = &XRSessionPrototype::initialize,
        .define_unforgeable_attributes = &XRSessionPrototype::define_unforgeable_attributes,
        .construct = &XRSessionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRSessionEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRSessionEvent"sv,
        .namespaced_name = "XRSessionEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &XRSessionEventConstructor::initialize,
        .initialize_prototype = &XRSessionEventPrototype::initialize,
        .define_unforgeable_attributes = &XRSessionEventPrototype::define_unforgeable_attributes,
        .construct = &XRSessionEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRSystemPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRSystem"sv,
        .namespaced_name = "XRSystem"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &XRSystemConstructor::initialize,
        .initialize_prototype = &XRSystemPrototype::initialize,
        .define_unforgeable_attributes = &XRSystemPrototype::define_unforgeable_attributes,
        .construct = &XRSystemConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XRWebGLLayerPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XRWebGLLayer"sv,
        .namespaced_name = "XRWebGLLayer"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<XRLayerPrototype>(realm, "XRLayer"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<XRLayerPrototype>(realm, "XRLayer"_fly_string); },
        .initialize_constructor = &XRWebGLLayerConstructor::initialize,
        .initialize_prototype = &XRWebGLLayerPrototype::initialize,
        .define_unforgeable_attributes = &XRWebGLLayerPrototype::define_unforgeable_attributes,
        .construct = &XRWebGLLayerConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<FormDataPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "FormData"sv,
        .namespaced_name = "FormData"sv,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &FormDataConstructor::initialize,
        .construct = &FormDataConstructor::construct,
    };

    auto prototype = realm.create<FormDataPrototype>(realm);
    m_prototypes.set("FormData"_fly_string, prototype);

    create_web_constructor(realm, metadata, prototype);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<ProgressEventPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "ProgressEvent"sv,
        .namespaced_name = "ProgressEvent"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventPrototype>(realm, "Event"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventPrototype>(realm, "Event"_fly_string); },
        .initialize_constructor = &ProgressEventConstructor::initialize,
        .initialize_prototype = &ProgressEventPrototype::initialize,
        .define_unforgeable_attributes = &ProgressEventPrototype::define_unforgeable_attributes,
        .construct = &ProgressEventConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XMLHttpRequestPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XMLHttpRequest"sv,
        .namespaced_name = "XMLHttpRequest"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<XMLHttpRequestEventTargetPrototype>(realm, "XMLHttpRequestEventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<XMLHttpRequestEventTargetPrototype>(realm, "XMLHttpRequestEventTarget"_fly_string); },
        .initialize_constructor = &XMLHttpRequestConstructor::initialize,
        .initialize_prototype = &XMLHttpRequestPrototype::initialize,
        .define_unforgeable_attributes = &XMLHttpRequestPrototype::define_unforgeable_attributes,
        .construct = &XMLHttpRequestConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XMLHttpRequestEventTargetPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XMLHttpRequestEventTarget"sv,
        .namespaced_name = "XMLHttpRequestEventTarget"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<EventTargetPrototype>(realm, "EventTarget"_fly_string); },
        .initialize_constructor = &XMLHttpRequestEventTargetConstructor::initialize,
        .initialize_prototype = &XMLHttpRequestEventTargetPrototype::initialize,
        .define_unforgeable_attributes = &XMLHttpRequestEventTargetPrototype::define_unforgeable_attributes,
        .construct = &XMLHttpRequestEventTargetConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XMLHttpRequestUploadPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XMLHttpRequestUpload"sv,
        .namespaced_name = "XMLHttpRequestUpload"sv,
        .ensure_parent_prototype = [](JS::Realm& realm) -> JS::Object& { return Web::Bindings::ensure_web_prototype<XMLHttpRequestEventTargetPrototype>(realm, "XMLHttpRequestEventTarget"_fly_string); },
        .ensure_parent_constructor = [](JS::Realm& realm) -> JS::NativeFunction& { return Web::Bindings::ensure_web_constructor<XMLHttpRequestEventTargetPrototype>(realm, "XMLHttpRequestEventTarget"_fly_string); },
        .initialize_constructor = &XMLHttpRequestUploadConstructor::initialize,
        .initialize_prototype = &XMLHttpRequestUploadPrototype::initialize,
        .define_unforgeable_attributes = &XMLHttpRequestUploadPrototype::define_unforgeable_attributes,
        .construct = &XMLHttpRequestUploadConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XPathEvaluatorPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XPathEvaluator"sv,
        .namespaced_name = "XPathEvaluator"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XPathEvaluatorConstructor::initialize,
        .initialize_prototype = &XPathEvaluatorPrototype::initialize,
        .define_unforgeable_attributes = &XPathEvaluatorPrototype::define_unforgeable_attributes,
        .construct = &XPathEvaluatorConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XPathExpressionPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XPathExpression"sv,
        .namespaced_name = "XPathExpression"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XPathExpressionConstructor::initialize,
        .initialize_prototype = &XPathExpressionPrototype::initialize,
        .define_unforgeable_attributes = &XPathExpressionPrototype::define_unforgeable_attributes,
        .construct = &XPathExpressionConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
template<>
WEB_API void Intrinsics::create_web_prototype_and_constructor<XPathResultPrototype>(JS::Realm& realm)
{
    static constexpr InterfaceObjectMetadata metadata {
        .name = "XPathResult"sv,
        .namespaced_name = "XPathResult"sv,
        .ensure_parent_prototype = nullptr,
        .ensure_parent_constructor = nullptr,
        .initialize_constructor = &XPathResultConstructor::initialize,
        .initialize_prototype = &XPathResultPrototype::initialize,
        .define_unforgeable_attributes = &XPathResultPrototype::define_unforgeable_attributes,
        .construct = &XPathResultConstructor::construct,
        .has_immutable_prototype = false,
    };
    create_web_prototype_and_constructor(realm, metadata);
}
}