/*
    This file is part of the WebKit open source project.
    This file has been generated by generate-bindings.pl. DO NOT MODIFY!

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "config.h"
#include "JSDOMWindow.h"

#include "BarProp.h"
#include "CSSRuleList.h"
#include "CSSStyleDeclaration.h"
#include "Console.h"
#include "Crypto.h"
#include "DOMApplicationCache.h"
#include "DOMSelection.h"
#include "DOMWindow.h"
#include "DOMWindowIndexedDatabase.h"
#include "DOMWindowQuota.h"
#include "DOMWindowWebDatabase.h"
#include "Database.h"
#include "Document.h"
#include "Element.h"
#include "Event.h"
#include "EventListener.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "History.h"
#include "JSAttr.h"
#include "JSBarProp.h"
#include "JSBeforeLoadEvent.h"
#include "JSBeforeUnloadEvent.h"
#include "JSBlob.h"
#include "JSCDATASection.h"
#include "JSCSSCharsetRule.h"
#include "JSCSSFontFaceRule.h"
#include "JSCSSImportRule.h"
#include "JSCSSMediaRule.h"
#include "JSCSSPageRule.h"
#include "JSCSSPrimitiveValue.h"
#include "JSCSSRule.h"
#include "JSCSSRuleList.h"
#include "JSCSSStyleDeclaration.h"
#include "JSCSSStyleRule.h"
#include "JSCSSStyleSheet.h"
#include "JSCSSValue.h"
#include "JSCSSValueList.h"
#include "JSCanvasGradient.h"
#include "JSCanvasPattern.h"
#include "JSCanvasRenderingContext2D.h"
#include "JSCharacterData.h"
#include "JSClientRect.h"
#include "JSClientRectList.h"
#include "JSClipboard.h"
#include "JSCloseEvent.h"
#include "JSComment.h"
#include "JSCompositionEvent.h"
#include "JSConsole.h"
#include "JSCounter.h"
#include "JSCrypto.h"
#include "JSCustomEvent.h"
#include "JSDOMApplicationCache.h"
#include "JSDOMBinding.h"
#include "JSDOMCoreException.h"
#include "JSDOMFormData.h"
#include "JSDOMImplementation.h"
#include "JSDOMMimeType.h"
#include "JSDOMMimeTypeArray.h"
#include "JSDOMParser.h"
#include "JSDOMPlugin.h"
#include "JSDOMPluginArray.h"
#include "JSDOMSelection.h"
#include "JSDOMSettableTokenList.h"
#include "JSDOMStringList.h"
#include "JSDOMStringMap.h"
#include "JSDOMTokenList.h"
#include "JSDOMURL.h"
#include "JSDOMWindow.h"
#include "JSDOMWindowShell.h"
#include "JSDatabaseCallback.h"
#include "JSDocument.h"
#include "JSDocumentFragment.h"
#include "JSDocumentType.h"
#include "JSElement.h"
#include "JSEntity.h"
#include "JSEntityReference.h"
#include "JSErrorEvent.h"
#include "JSErrorHandler.h"
#include "JSEvent.h"
#include "JSEventException.h"
#include "JSEventListener.h"
#include "JSEventSource.h"
#include "JSFile.h"
#include "JSFileList.h"
#include "JSFocusEvent.h"
#include "JSHTMLAllCollection.h"
#include "JSHTMLAnchorElement.h"
#include "JSHTMLAppletElement.h"
#include "JSHTMLAreaElement.h"
#include "JSHTMLBRElement.h"
#include "JSHTMLBaseElement.h"
#include "JSHTMLBaseFontElement.h"
#include "JSHTMLBodyElement.h"
#include "JSHTMLButtonElement.h"
#include "JSHTMLCanvasElement.h"
#include "JSHTMLCollection.h"
#include "JSHTMLDListElement.h"
#include "JSHTMLDirectoryElement.h"
#include "JSHTMLDivElement.h"
#include "JSHTMLDocument.h"
#include "JSHTMLElement.h"
#include "JSHTMLEmbedElement.h"
#include "JSHTMLFieldSetElement.h"
#include "JSHTMLFontElement.h"
#include "JSHTMLFormControlsCollection.h"
#include "JSHTMLFormElement.h"
#include "JSHTMLFrameElement.h"
#include "JSHTMLFrameSetElement.h"
#include "JSHTMLHRElement.h"
#include "JSHTMLHeadElement.h"
#include "JSHTMLHeadingElement.h"
#include "JSHTMLHtmlElement.h"
#include "JSHTMLIFrameElement.h"
#include "JSHTMLImageElement.h"
#include "JSHTMLInputElement.h"
#include "JSHTMLKeygenElement.h"
#include "JSHTMLLIElement.h"
#include "JSHTMLLabelElement.h"
#include "JSHTMLLegendElement.h"
#include "JSHTMLLinkElement.h"
#include "JSHTMLMapElement.h"
#include "JSHTMLMarqueeElement.h"
#include "JSHTMLMenuElement.h"
#include "JSHTMLMetaElement.h"
#include "JSHTMLModElement.h"
#include "JSHTMLOListElement.h"
#include "JSHTMLObjectElement.h"
#include "JSHTMLOptGroupElement.h"
#include "JSHTMLOptionElement.h"
#include "JSHTMLOptionsCollection.h"
#include "JSHTMLOutputElement.h"
#include "JSHTMLParagraphElement.h"
#include "JSHTMLParamElement.h"
#include "JSHTMLPreElement.h"
#include "JSHTMLQuoteElement.h"
#include "JSHTMLScriptElement.h"
#include "JSHTMLSelectElement.h"
#include "JSHTMLSpanElement.h"
#include "JSHTMLStyleElement.h"
#include "JSHTMLTableCaptionElement.h"
#include "JSHTMLTableCellElement.h"
#include "JSHTMLTableColElement.h"
#include "JSHTMLTableElement.h"
#include "JSHTMLTableRowElement.h"
#include "JSHTMLTableSectionElement.h"
#include "JSHTMLTextAreaElement.h"
#include "JSHTMLTitleElement.h"
#include "JSHTMLUListElement.h"
#include "JSHTMLUnknownElement.h"
#include "JSHashChangeEvent.h"
#include "JSHistory.h"
#include "JSImageData.h"
#include "JSKeyboardEvent.h"
#include "JSLocation.h"
#include "JSMediaList.h"
#include "JSMediaQueryList.h"
#include "JSMessageEvent.h"
#include "JSMessagePort.h"
#include "JSMouseEvent.h"
#include "JSMutationEvent.h"
#include "JSMutationObserver.h"
#include "JSMutationRecord.h"
#include "JSNamedNodeMap.h"
#include "JSNavigator.h"
#include "JSNode.h"
#include "JSNodeFilter.h"
#include "JSNodeIterator.h"
#include "JSNodeList.h"
#include "JSNotation.h"
#include "JSOverflowEvent.h"
#include "JSPageTransitionEvent.h"
#include "JSPerformance.h"
#include "JSPopStateEvent.h"
#include "JSProcessingInstruction.h"
#include "JSProgressEvent.h"
#include "JSRGBColor.h"
#include "JSRange.h"
#include "JSRangeException.h"
#include "JSRect.h"
#include "JSRequestAnimationFrameCallback.h"
#include "JSScreen.h"
#include "JSStorage.h"
#include "JSStorageEvent.h"
#include "JSStyleMedia.h"
#include "JSStyleSheet.h"
#include "JSStyleSheetList.h"
#include "JSText.h"
#include "JSTextEvent.h"
#include "JSTextMetrics.h"
#include "JSTransitionEvent.h"
#include "JSTreeWalker.h"
#include "JSUIEvent.h"
#include "JSWebKitAnimationEvent.h"
#include "JSWebKitCSSKeyframeRule.h"
#include "JSWebKitCSSKeyframesRule.h"
#include "JSWebKitCSSMatrix.h"
#include "JSWebKitCSSTransformValue.h"
#include "JSWebKitPoint.h"
#include "JSWebKitTransitionEvent.h"
#include "JSWheelEvent.h"
#include "JSWorker.h"
#include "JSXMLHttpRequest.h"
#include "JSXMLHttpRequestException.h"
#include "JSXMLHttpRequestProgressEvent.h"
#include "JSXMLHttpRequestUpload.h"
#include "JSXMLSerializer.h"
#include "JSXPathEvaluator.h"
#include "JSXPathException.h"
#include "JSXPathExpression.h"
#include "JSXPathResult.h"
#include "Location.h"
#include "MediaQueryList.h"
#include "Navigator.h"
#include "Performance.h"
#include "RuntimeEnabledFeatures.h"
#include "Screen.h"
#include "Settings.h"
#include "Storage.h"
#include "StyleMedia.h"
#include "StyleProperties.h"
#include "URL.h"
#include "WebKitPoint.h"
#include <runtime/Error.h>
#include <runtime/JSString.h>
#include <wtf/GetPtr.h>

#if ENABLE(BLOB)
#include "JSFileError.h"
#include "JSFileReader.h"
#endif

#if ENABLE(CANVAS_PATH)
#include "JSDOMPath.h"
#endif

#if ENABLE(CANVAS_PROXY)
#include "JSCanvasProxy.h"
#endif

#if ENABLE(CHANNEL_MESSAGING)
#include "JSMessageChannel.h"
#endif

#if ENABLE(CSP_NEXT)
#include "JSDOMSecurityPolicy.h"
#include "JSSecurityPolicyViolationEvent.h"
#endif

#if ENABLE(CSS3_CONDITIONAL_RULES)
#include "DOMWindowCSS.h"
#include "JSDOMWindowCSS.h"
#endif

#if ENABLE(CSS_DEVICE_ADAPTATION)
#include "JSWebKitCSSViewportRule.h"
#endif

#if ENABLE(CSS_FILTERS)
#include "JSWebKitCSSFilterValue.h"
#endif

#if ENABLE(CSS_REGIONS)
#include "JSWebKitCSSRegionRule.h"
#endif

#if ENABLE(DATALIST_ELEMENT)
#include "JSHTMLDataListElement.h"
#endif

#if ENABLE(DEVICE_ORIENTATION)
#include "JSDeviceMotionEvent.h"
#include "JSDeviceOrientationEvent.h"
#endif

#if ENABLE(ENCRYPTED_MEDIA)
#include "JSMediaKeyEvent.h"
#endif

#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
#include "JSMediaKeyError.h"
#endif

#if ENABLE(INDEXED_DATABASE)
#include "IDBFactory.h"
#include "JSIDBCursor.h"
#include "JSIDBCursorWithValue.h"
#include "JSIDBDatabase.h"
#include "JSIDBFactory.h"
#include "JSIDBIndex.h"
#include "JSIDBKeyRange.h"
#include "JSIDBObjectStore.h"
#include "JSIDBOpenDBRequest.h"
#include "JSIDBRequest.h"
#include "JSIDBTransaction.h"
#include "JSIDBVersionChangeEvent.h"
#endif

#if ENABLE(INPUT_SPEECH)
#include "JSSpeechInputEvent.h"
#endif

#if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(TOUCH_EVENTS)
#include "JSTouch.h"
#include "JSTouchList.h"
#endif

#if ENABLE(MEDIA_SOURCE)
#include "JSMediaSource.h"
#endif

#if ENABLE(MEDIA_STREAM)
#include "JSAudioStreamTrack.h"
#include "JSMediaStream.h"
#include "JSMediaStreamEvent.h"
#include "JSMediaStreamTrack.h"
#include "JSMediaStreamTrackEvent.h"
#include "JSRTCIceCandidate.h"
#include "JSRTCPeerConnection.h"
#include "JSRTCSessionDescription.h"
#include "JSVideoStreamTrack.h"
#endif

#if ENABLE(METER_ELEMENT)
#include "JSHTMLMeterElement.h"
#endif

#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
#include "JSNotification.h"
#endif

#if ENABLE(PERFORMANCE_TIMELINE)
#include "JSPerformanceEntry.h"
#endif

#if ENABLE(PROGRESS_ELEMENT)
#include "JSHTMLProgressElement.h"
#endif

#if ENABLE(PROXIMITY_EVENTS)
#include "JSDeviceProximityEvent.h"
#endif

#if ENABLE(QUOTA)
#include "JSStorageInfo.h"
#include "StorageInfo.h"
#endif

#if ENABLE(RESOURCE_TIMING)
#include "JSPerformanceResourceTiming.h"
#endif

#if ENABLE(SHADOW_DOM)
#include "JSCSSHostRule.h"
#include "JSShadowRoot.h"
#endif

#if ENABLE(SHARED_WORKERS)
#include "JSSharedWorker.h"
#endif

#if ENABLE(SQL_DATABASE)
#include "JSDatabase.h"
#include "JSSQLException.h"
#endif

#if ENABLE(SVG)
#include "JSSVGAElement.h"
#include "JSSVGAngle.h"
#include "JSSVGAnimateColorElement.h"
#include "JSSVGAnimateElement.h"
#include "JSSVGAnimateMotionElement.h"
#include "JSSVGAnimateTransformElement.h"
#include "JSSVGAnimatedAngle.h"
#include "JSSVGAnimatedBoolean.h"
#include "JSSVGAnimatedEnumeration.h"
#include "JSSVGAnimatedInteger.h"
#include "JSSVGAnimatedLength.h"
#include "JSSVGAnimatedLengthList.h"
#include "JSSVGAnimatedNumber.h"
#include "JSSVGAnimatedNumberList.h"
#include "JSSVGAnimatedPreserveAspectRatio.h"
#include "JSSVGAnimatedRect.h"
#include "JSSVGAnimatedString.h"
#include "JSSVGAnimatedTransformList.h"
#include "JSSVGAnimationElement.h"
#include "JSSVGCircleElement.h"
#include "JSSVGClipPathElement.h"
#include "JSSVGColor.h"
#include "JSSVGCursorElement.h"
#include "JSSVGDefsElement.h"
#include "JSSVGDescElement.h"
#include "JSSVGDocument.h"
#include "JSSVGElement.h"
#include "JSSVGElementInstance.h"
#include "JSSVGElementInstanceList.h"
#include "JSSVGEllipseElement.h"
#include "JSSVGException.h"
#include "JSSVGForeignObjectElement.h"
#include "JSSVGGElement.h"
#include "JSSVGGradientElement.h"
#include "JSSVGGraphicsElement.h"
#include "JSSVGImageElement.h"
#include "JSSVGLength.h"
#include "JSSVGLengthList.h"
#include "JSSVGLineElement.h"
#include "JSSVGLinearGradientElement.h"
#include "JSSVGMPathElement.h"
#include "JSSVGMarkerElement.h"
#include "JSSVGMaskElement.h"
#include "JSSVGMatrix.h"
#include "JSSVGMetadataElement.h"
#include "JSSVGNumber.h"
#include "JSSVGNumberList.h"
#include "JSSVGPaint.h"
#include "JSSVGPathElement.h"
#include "JSSVGPathSeg.h"
#include "JSSVGPathSegArcAbs.h"
#include "JSSVGPathSegArcRel.h"
#include "JSSVGPathSegClosePath.h"
#include "JSSVGPathSegCurvetoCubicAbs.h"
#include "JSSVGPathSegCurvetoCubicRel.h"
#include "JSSVGPathSegCurvetoCubicSmoothAbs.h"
#include "JSSVGPathSegCurvetoCubicSmoothRel.h"
#include "JSSVGPathSegCurvetoQuadraticAbs.h"
#include "JSSVGPathSegCurvetoQuadraticRel.h"
#include "JSSVGPathSegCurvetoQuadraticSmoothAbs.h"
#include "JSSVGPathSegCurvetoQuadraticSmoothRel.h"
#include "JSSVGPathSegLinetoAbs.h"
#include "JSSVGPathSegLinetoHorizontalAbs.h"
#include "JSSVGPathSegLinetoHorizontalRel.h"
#include "JSSVGPathSegLinetoRel.h"
#include "JSSVGPathSegLinetoVerticalAbs.h"
#include "JSSVGPathSegLinetoVerticalRel.h"
#include "JSSVGPathSegList.h"
#include "JSSVGPathSegMovetoAbs.h"
#include "JSSVGPathSegMovetoRel.h"
#include "JSSVGPatternElement.h"
#include "JSSVGPoint.h"
#include "JSSVGPointList.h"
#include "JSSVGPolygonElement.h"
#include "JSSVGPolylineElement.h"
#include "JSSVGPreserveAspectRatio.h"
#include "JSSVGRadialGradientElement.h"
#include "JSSVGRect.h"
#include "JSSVGRectElement.h"
#include "JSSVGRenderingIntent.h"
#include "JSSVGSVGElement.h"
#include "JSSVGScriptElement.h"
#include "JSSVGSetElement.h"
#include "JSSVGStopElement.h"
#include "JSSVGStringList.h"
#include "JSSVGStyleElement.h"
#include "JSSVGSwitchElement.h"
#include "JSSVGSymbolElement.h"
#include "JSSVGTRefElement.h"
#include "JSSVGTSpanElement.h"
#include "JSSVGTextContentElement.h"
#include "JSSVGTextElement.h"
#include "JSSVGTextPathElement.h"
#include "JSSVGTextPositioningElement.h"
#include "JSSVGTitleElement.h"
#include "JSSVGTransform.h"
#include "JSSVGTransformList.h"
#include "JSSVGUnitTypes.h"
#include "JSSVGUseElement.h"
#include "JSSVGViewElement.h"
#include "JSSVGViewSpec.h"
#include "JSSVGZoomEvent.h"
#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
#include "JSSVGComponentTransferFunctionElement.h"
#include "JSSVGFEBlendElement.h"
#include "JSSVGFEColorMatrixElement.h"
#include "JSSVGFEComponentTransferElement.h"
#include "JSSVGFECompositeElement.h"
#include "JSSVGFEConvolveMatrixElement.h"
#include "JSSVGFEDiffuseLightingElement.h"
#include "JSSVGFEDisplacementMapElement.h"
#include "JSSVGFEDistantLightElement.h"
#include "JSSVGFEDropShadowElement.h"
#include "JSSVGFEFloodElement.h"
#include "JSSVGFEFuncAElement.h"
#include "JSSVGFEFuncBElement.h"
#include "JSSVGFEFuncGElement.h"
#include "JSSVGFEFuncRElement.h"
#include "JSSVGFEGaussianBlurElement.h"
#include "JSSVGFEImageElement.h"
#include "JSSVGFEMergeElement.h"
#include "JSSVGFEMergeNodeElement.h"
#include "JSSVGFEMorphologyElement.h"
#include "JSSVGFEOffsetElement.h"
#include "JSSVGFEPointLightElement.h"
#include "JSSVGFESpecularLightingElement.h"
#include "JSSVGFESpotLightElement.h"
#include "JSSVGFETileElement.h"
#include "JSSVGFETurbulenceElement.h"
#include "JSSVGFilterElement.h"
#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
#include "JSSVGAltGlyphDefElement.h"
#include "JSSVGAltGlyphElement.h"
#include "JSSVGAltGlyphItemElement.h"
#include "JSSVGFontElement.h"
#include "JSSVGFontFaceElement.h"
#include "JSSVGFontFaceFormatElement.h"
#include "JSSVGFontFaceNameElement.h"
#include "JSSVGFontFaceSrcElement.h"
#include "JSSVGFontFaceUriElement.h"
#include "JSSVGGlyphElement.h"
#include "JSSVGGlyphRefElement.h"
#include "JSSVGHKernElement.h"
#include "JSSVGMissingGlyphElement.h"
#include "JSSVGVKernElement.h"
#endif

#if ENABLE(TEMPLATE_ELEMENT)
#include "JSHTMLTemplateElement.h"
#endif

#if ENABLE(TOUCH_EVENTS)
#include "JSTouchEvent.h"
#endif

#if ENABLE(USER_TIMING)
#include "JSPerformanceMark.h"
#include "JSPerformanceMeasure.h"
#endif

#if ENABLE(VIDEO)
#include "JSHTMLAudioElement.h"
#include "JSHTMLMediaElement.h"
#include "JSHTMLSourceElement.h"
#include "JSHTMLVideoElement.h"
#include "JSMediaController.h"
#include "JSMediaError.h"
#include "JSTimeRanges.h"
#endif

#if ENABLE(VIDEO_TRACK)
#include "JSHTMLTrackElement.h"
#include "JSTextTrack.h"
#include "JSTextTrackCue.h"
#include "JSTextTrackCueList.h"
#include "JSTextTrackList.h"
#include "JSTrackEvent.h"
#endif

#if ENABLE(WEBGL)
#include "JSWebGLActiveInfo.h"
#include "JSWebGLBuffer.h"
#include "JSWebGLContextEvent.h"
#include "JSWebGLFramebuffer.h"
#include "JSWebGLProgram.h"
#include "JSWebGLRenderbuffer.h"
#include "JSWebGLRenderingContext.h"
#include "JSWebGLShader.h"
#include "JSWebGLShaderPrecisionFormat.h"
#include "JSWebGLTexture.h"
#include "JSWebGLUniformLocation.h"
#endif

#if ENABLE(WEB_AUDIO)
#include "JSAnalyserNode.h"
#include "JSAudioBuffer.h"
#include "JSAudioBufferSourceNode.h"
#include "JSAudioContext.h"
#include "JSAudioDestinationNode.h"
#include "JSAudioListener.h"
#include "JSAudioNode.h"
#include "JSAudioParam.h"
#include "JSAudioProcessingEvent.h"
#include "JSBiquadFilterNode.h"
#include "JSChannelMergerNode.h"
#include "JSChannelSplitterNode.h"
#include "JSConvolverNode.h"
#include "JSDelayNode.h"
#include "JSDynamicsCompressorNode.h"
#include "JSGainNode.h"
#include "JSOfflineAudioCompletionEvent.h"
#include "JSOfflineAudioContext.h"
#include "JSOscillatorNode.h"
#include "JSPannerNode.h"
#include "JSPeriodicWave.h"
#include "JSScriptProcessorNode.h"
#include "JSWaveShaperNode.h"
#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
#include "JSMediaStreamAudioDestinationNode.h"
#include "JSMediaStreamAudioSourceNode.h"
#endif

#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
#include "JSMediaElementAudioSourceNode.h"
#endif

#if ENABLE(WEB_SOCKETS)
#include "JSWebSocket.h"
#endif

#if ENABLE(WEB_TIMING)
#include "JSPerformanceNavigation.h"
#include "JSPerformanceTiming.h"
#endif

#if ENABLE(XSLT)
#include "JSXSLTProcessor.h"
#endif

using namespace JSC;

namespace WebCore {

/* Hash table */

static const HashTableValue JSDOMWindowTableValues[] =
{
    { "screen", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreen), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreen) },
    { "history", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHistory), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHistory) },
    { "locationbar", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowLocationbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowLocationbar) },
    { "menubar", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMenubar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMenubar) },
    { "personalbar", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPersonalbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPersonalbar) },
    { "scrollbars", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScrollbars), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScrollbars) },
    { "statusbar", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStatusbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStatusbar) },
    { "toolbar", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowToolbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowToolbar) },
    { "navigator", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNavigator), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNavigator) },
    { "clientInformation", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowClientInformation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowClientInformation) },
    { "crypto", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCrypto), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "location", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowLocation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowLocation) },
    { "event", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEvent), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEvent) },
    { "frameElement", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFrameElement), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "offscreenBuffering", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOffscreenBuffering), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOffscreenBuffering) },
    { "outerHeight", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOuterHeight), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOuterHeight) },
    { "outerWidth", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOuterWidth), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOuterWidth) },
    { "innerHeight", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowInnerHeight), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowInnerHeight) },
    { "innerWidth", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowInnerWidth), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowInnerWidth) },
    { "screenX", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreenX), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreenX) },
    { "screenY", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreenY), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreenY) },
    { "screenLeft", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreenLeft), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreenLeft) },
    { "screenTop", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreenTop), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreenTop) },
    { "scrollX", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScrollX), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScrollX) },
    { "scrollY", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScrollY), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScrollY) },
    { "pageXOffset", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPageXOffset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "pageYOffset", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPageYOffset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "closed", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowClosed), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "length", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowLength), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowLength) },
    { "name", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowName), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowName) },
    { "status", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStatus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStatus) },
    { "defaultStatus", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDefaultStatus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDefaultStatus) },
    { "defaultstatus", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDefaultstatus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDefaultstatus) },
    { "self", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSelf), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSelf) },
    { "window", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWindow), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "frames", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFrames), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFrames) },
    { "opener", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOpener), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOpener) },
    { "parent", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowParent), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowParent) },
    { "top", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTop), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "document", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "styleMedia", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStyleMedia), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "devicePixelRatio", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDevicePixelRatio), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDevicePixelRatio) },
    { "applicationCache", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowApplicationCache), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "sessionStorage", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSessionStorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "localStorage", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowLocalStorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
    { "console", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowConsole), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowConsole) },
    { "performance", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformance), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformance) },
#if ENABLE(CSS3_CONDITIONAL_RULES)
    { "CSS", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSS), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSS) },
#endif
    { "onabort", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnabort), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnabort) },
    { "onbeforeunload", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnbeforeunload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnbeforeunload) },
    { "onblur", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnblur), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnblur) },
    { "oncanplay", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOncanplay), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOncanplay) },
    { "oncanplaythrough", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOncanplaythrough), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOncanplaythrough) },
    { "onchange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnchange) },
    { "onclick", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnclick), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnclick) },
    { "oncontextmenu", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOncontextmenu), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOncontextmenu) },
    { "ondblclick", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndblclick), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndblclick) },
    { "ondrag", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndrag), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndrag) },
    { "ondragend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndragend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndragend) },
    { "ondragenter", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndragenter), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndragenter) },
    { "ondragleave", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndragleave), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndragleave) },
    { "ondragover", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndragover), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndragover) },
    { "ondragstart", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndragstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndragstart) },
    { "ondrop", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndrop), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndrop) },
    { "ondurationchange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndurationchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndurationchange) },
    { "onemptied", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnemptied), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnemptied) },
    { "onended", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnended), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnended) },
    { "onerror", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnerror), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnerror) },
    { "onfocus", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnfocus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnfocus) },
    { "onhashchange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnhashchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnhashchange) },
    { "oninput", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOninput), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOninput) },
    { "oninvalid", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOninvalid), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOninvalid) },
    { "onkeydown", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnkeydown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnkeydown) },
    { "onkeypress", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnkeypress), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnkeypress) },
    { "onkeyup", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnkeyup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnkeyup) },
    { "onload", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnload) },
    { "onloadeddata", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnloadeddata), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnloadeddata) },
    { "onloadedmetadata", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnloadedmetadata), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnloadedmetadata) },
    { "onloadstart", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnloadstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnloadstart) },
    { "onmessage", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmessage) },
    { "onmousedown", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmousedown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmousedown) },
    { "onmouseenter", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmouseenter), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmouseenter) },
    { "onmouseleave", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmouseleave), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmouseleave) },
    { "onmousemove", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmousemove), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmousemove) },
    { "onmouseout", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmouseout), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmouseout) },
    { "onmouseover", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmouseover), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmouseover) },
    { "onmouseup", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmouseup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmouseup) },
    { "onmousewheel", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnmousewheel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnmousewheel) },
    { "onoffline", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnoffline), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnoffline) },
    { "ononline", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnonline), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnonline) },
    { "onpagehide", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnpagehide), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnpagehide) },
    { "onpageshow", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnpageshow), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnpageshow) },
    { "onpause", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnpause), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnpause) },
    { "onplay", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnplay), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnplay) },
    { "onplaying", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnplaying), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnplaying) },
    { "onpopstate", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnpopstate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnpopstate) },
    { "onprogress", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnprogress), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnprogress) },
    { "onratechange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnratechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnratechange) },
    { "onresize", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnresize), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnresize) },
    { "onscroll", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnscroll), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnscroll) },
    { "onseeked", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnseeked), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnseeked) },
    { "onseeking", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnseeking), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnseeking) },
    { "onselect", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnselect), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnselect) },
    { "onstalled", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnstalled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnstalled) },
    { "onstorage", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnstorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnstorage) },
    { "onsubmit", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnsubmit), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnsubmit) },
    { "onsuspend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnsuspend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnsuspend) },
    { "ontimeupdate", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntimeupdate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntimeupdate) },
    { "onunload", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnunload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnunload) },
    { "onvolumechange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnvolumechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnvolumechange) },
    { "onwaiting", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwaiting), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwaiting) },
    { "onwheel", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwheel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwheel) },
    { "onreset", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnreset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnreset) },
    { "onsearch", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnsearch), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnsearch) },
    { "onwebkitanimationend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwebkitanimationend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwebkitanimationend) },
    { "onwebkitanimationiteration", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwebkitanimationiteration), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwebkitanimationiteration) },
    { "onwebkitanimationstart", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwebkitanimationstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwebkitanimationstart) },
    { "onwebkittransitionend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwebkittransitionend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwebkittransitionend) },
    { "ontransitionend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntransitionend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntransitionend) },
#if ENABLE(TOUCH_EVENTS)
    { "ontouchstart", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntouchstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntouchstart) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "ontouchmove", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntouchmove), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntouchmove) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "ontouchend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntouchend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntouchend) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "ontouchcancel", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOntouchcancel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOntouchcancel) },
#endif
#if ENABLE(IOS_GESTURE_EVENTS)
    { "ongesturestart", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOngesturestart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOngesturestart) },
#endif
#if ENABLE(IOS_GESTURE_EVENTS)
    { "ongesturechange", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOngesturechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOngesturechange) },
#endif
#if ENABLE(IOS_GESTURE_EVENTS)
    { "ongestureend", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOngestureend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOngestureend) },
#endif
#if ENABLE(DEVICE_ORIENTATION)
    { "ondevicemotion", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndevicemotion), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndevicemotion) },
#endif
#if ENABLE(DEVICE_ORIENTATION)
    { "ondeviceorientation", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOndeviceorientation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOndeviceorientation) },
#endif
#if ENABLE(PROXIMITY_EVENTS)
    { "onwebkitdeviceproximity", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOnwebkitdeviceproximity), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOnwebkitdeviceproximity) },
#endif
    { "Image", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowImageConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowImageConstructor) },
    { "XMLDocument", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLDocumentConstructor) },
#if ENABLE(TOUCH_EVENTS)
    { "Touch", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTouchConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTouchConstructor) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "TouchList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTouchListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTouchListConstructor) },
#endif
#if ENABLE(BLOB)
    { "webkitURL", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitURLConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitURLConstructor) },
#endif
    { "WebKitMutationObserver", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitMutationObserverConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitMutationObserverConstructor) },
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBCursor", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBCursorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBCursorConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBDatabase", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBDatabaseConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBDatabaseConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBFactory", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBFactoryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBFactoryConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBIndex", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBIndexConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBIndexConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBKeyRange", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBKeyRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBKeyRangeConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBObjectStore", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBObjectStoreConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBObjectStoreConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBRequest", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBRequestConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIDBTransaction", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIDBTransactionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitIDBTransactionConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBCursor", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBCursorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBCursorConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBCursorWithValue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBCursorWithValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBCursorWithValueConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBDatabase", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBDatabaseConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBDatabaseConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBFactory", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBFactoryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBFactoryConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBIndex", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBIndexConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBIndexConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBKeyRange", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBKeyRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBKeyRangeConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBObjectStore", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBObjectStoreConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBObjectStoreConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBOpenDBRequest", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBOpenDBRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBOpenDBRequestConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBRequest", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBRequestConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBTransaction", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBTransactionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBTransactionConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "IDBVersionChangeEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIDBVersionChangeEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowIDBVersionChangeEventConstructor) },
#endif
#if ENABLE(MEDIA_SOURCE)
    { "MediaSource", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaSourceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaSourceConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "AudioStreamTrack", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioStreamTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioStreamTrackConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "webkitMediaStream", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitMediaStreamConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitMediaStreamConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "MediaStreamEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaStreamEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaStreamEventConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "MediaStreamTrack", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaStreamTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaStreamTrackConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "MediaStreamTrackEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaStreamTrackEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaStreamTrackEventConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "RTCIceCandidate", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRTCIceCandidateConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRTCIceCandidateConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "webkitRTCPeerConnection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitRTCPeerConnectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitRTCPeerConnectionConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "RTCSessionDescription", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRTCSessionDescriptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRTCSessionDescriptionConstructor) },
#endif
#if ENABLE(MEDIA_STREAM)
    { "VideoStreamTrack", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowVideoStreamTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowVideoStreamTrackConstructor) },
#endif
#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
    { "Notification", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNotificationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNotificationConstructor) },
#endif
#if ENABLE(PROXIMITY_EVENTS)
    { "DeviceProximityEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDeviceProximityEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDeviceProximityEventConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AnalyserNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAnalyserNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAnalyserNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioBuffer", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioBufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioBufferConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioBufferSourceNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioBufferSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioBufferSourceNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "webkitAudioContext", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitAudioContextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitAudioContextConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioDestinationNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioDestinationNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioDestinationNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioListener", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioListenerConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioParam", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioParamConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioParamConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "AudioProcessingEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioProcessingEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioProcessingEventConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "BiquadFilterNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowBiquadFilterNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowBiquadFilterNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "ChannelMergerNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowChannelMergerNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowChannelMergerNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "ChannelSplitterNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowChannelSplitterNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowChannelSplitterNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "ConvolverNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowConvolverNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowConvolverNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "DelayNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDelayNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDelayNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "DynamicsCompressorNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDynamicsCompressorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDynamicsCompressorNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "GainNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowGainNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowGainNodeConstructor) },
#endif
#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
    { "MediaElementAudioSourceNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaElementAudioSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaElementAudioSourceNodeConstructor) },
#endif
#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
    { "MediaStreamAudioDestinationNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaStreamAudioDestinationNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaStreamAudioDestinationNodeConstructor) },
#endif
#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
    { "MediaStreamAudioSourceNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaStreamAudioSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaStreamAudioSourceNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "OfflineAudioCompletionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOfflineAudioCompletionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOfflineAudioCompletionEventConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "webkitOfflineAudioContext", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitOfflineAudioContextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitOfflineAudioContextConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "OscillatorNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOscillatorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOscillatorNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "webkitAudioPannerNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitAudioPannerNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebkitAudioPannerNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "PeriodicWave", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPeriodicWaveConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPeriodicWaveConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "ScriptProcessorNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScriptProcessorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScriptProcessorNodeConstructor) },
#endif
#if ENABLE(WEB_AUDIO)
    { "WaveShaperNode", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWaveShaperNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWaveShaperNodeConstructor) },
#endif
#if ENABLE(SQL_DATABASE)
    { "SQLException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSQLExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSQLExceptionConstructor) },
#endif
    { "CloseEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCloseEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCloseEventConstructor) },
#if ENABLE(WEB_SOCKETS)
    { "WebSocket", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebSocketConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebSocketConstructor) },
#endif
    { "CSSCharsetRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSCharsetRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSCharsetRuleConstructor) },
    { "CSSFontFaceRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSFontFaceRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSFontFaceRuleConstructor) },
#if ENABLE(SHADOW_DOM)
    { "CSSHostRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSHostRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSHostRuleConstructor) },
#endif
    { "CSSImportRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSImportRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSImportRuleConstructor) },
    { "CSSMediaRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSMediaRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSMediaRuleConstructor) },
    { "CSSPageRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSPageRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSPageRuleConstructor) },
    { "CSSPrimitiveValue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSPrimitiveValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSPrimitiveValueConstructor) },
    { "CSSRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSRuleConstructor) },
    { "CSSRuleList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSRuleListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSRuleListConstructor) },
    { "CSSStyleDeclaration", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSStyleDeclarationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSStyleDeclarationConstructor) },
    { "CSSStyleRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSStyleRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSStyleRuleConstructor) },
    { "CSSStyleSheet", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSStyleSheetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSStyleSheetConstructor) },
    { "CSSValue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSValueConstructor) },
    { "CSSValueList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCSSValueListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCSSValueListConstructor) },
    { "Counter", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCounterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCounterConstructor) },
    { "MediaList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaListConstructor) },
    { "RGBColor", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRGBColorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRGBColorConstructor) },
    { "Rect", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRectConstructor) },
    { "StyleSheet", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStyleSheetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStyleSheetConstructor) },
    { "StyleSheetList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStyleSheetListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStyleSheetListConstructor) },
#if ENABLE(CSS_FILTERS)
    { "WebKitCSSFilterValue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSFilterValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSFilterValueConstructor) },
#endif
    { "WebKitCSSKeyframeRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSKeyframeRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSKeyframeRuleConstructor) },
    { "WebKitCSSKeyframesRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSKeyframesRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSKeyframesRuleConstructor) },
    { "WebKitCSSMatrix", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSMatrixConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSMatrixConstructor) },
#if ENABLE(CSS_REGIONS)
    { "WebKitCSSRegionRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSRegionRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSRegionRuleConstructor) },
#endif
    { "WebKitCSSTransformValue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSTransformValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSTransformValueConstructor) },
#if ENABLE(CSS_DEVICE_ADAPTATION)
    { "WebKitCSSViewportRule", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitCSSViewportRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitCSSViewportRuleConstructor) },
#endif
    { "Attr", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAttrConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAttrConstructor) },
    { "BeforeLoadEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowBeforeLoadEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowBeforeLoadEventConstructor) },
    { "BeforeUnloadEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowBeforeUnloadEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowBeforeUnloadEventConstructor) },
    { "CDATASection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCDATASectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCDATASectionConstructor) },
    { "CharacterData", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCharacterDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCharacterDataConstructor) },
    { "ClientRect", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowClientRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowClientRectConstructor) },
    { "ClientRectList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowClientRectListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowClientRectListConstructor) },
    { "Clipboard", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowClipboardConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowClipboardConstructor) },
    { "Comment", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCommentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCommentConstructor) },
    { "CompositionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCompositionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCompositionEventConstructor) },
    { "CustomEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCustomEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCustomEventConstructor) },
    { "DOMException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMExceptionConstructor) },
    { "DOMImplementation", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMImplementationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMImplementationConstructor) },
    { "DOMStringList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMStringListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMStringListConstructor) },
    { "DOMStringMap", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMStringMapConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMStringMapConstructor) },
#if ENABLE(DEVICE_ORIENTATION)
    { "DeviceMotionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDeviceMotionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDeviceMotionEventConstructor) },
#endif
#if ENABLE(DEVICE_ORIENTATION)
    { "DeviceOrientationEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDeviceOrientationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDeviceOrientationEventConstructor) },
#endif
    { "Document", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDocumentConstructor) },
    { "DocumentFragment", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDocumentFragmentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDocumentFragmentConstructor) },
    { "DocumentType", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDocumentTypeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDocumentTypeConstructor) },
    { "Element", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowElementConstructor) },
    { "Entity", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEntityConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEntityConstructor) },
    { "EntityReference", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEntityReferenceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEntityReferenceConstructor) },
    { "ErrorEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowErrorEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowErrorEventConstructor) },
    { "Event", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEventConstructor) },
    { "EventException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEventExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEventExceptionConstructor) },
    { "FocusEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFocusEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFocusEventConstructor) },
    { "HashChangeEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHashChangeEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHashChangeEventConstructor) },
    { "KeyboardEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowKeyboardEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowKeyboardEventConstructor) },
#if ENABLE(CHANNEL_MESSAGING)
    { "MessageChannel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMessageChannelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMessageChannelConstructor) },
#endif
    { "MessageEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMessageEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMessageEventConstructor) },
    { "MessagePort", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMessagePortConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMessagePortConstructor) },
    { "MouseEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMouseEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMouseEventConstructor) },
    { "MutationEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMutationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMutationEventConstructor) },
    { "MutationObserver", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMutationObserverConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMutationObserverConstructor) },
    { "MutationRecord", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMutationRecordConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMutationRecordConstructor) },
    { "NamedNodeMap", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNamedNodeMapConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNamedNodeMapConstructor) },
    { "Node", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNodeConstructor) },
    { "NodeFilter", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNodeFilterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNodeFilterConstructor) },
    { "NodeIterator", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNodeIteratorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNodeIteratorConstructor) },
    { "NodeList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNodeListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNodeListConstructor) },
    { "Notation", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNotationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNotationConstructor) },
    { "OverflowEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOverflowEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOverflowEventConstructor) },
    { "PageTransitionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPageTransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPageTransitionEventConstructor) },
    { "PopStateEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPopStateEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPopStateEventConstructor) },
    { "ProcessingInstruction", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowProcessingInstructionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowProcessingInstructionConstructor) },
    { "ProgressEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowProgressEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowProgressEventConstructor) },
    { "Range", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRangeConstructor) },
    { "RangeException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowRangeExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowRangeExceptionConstructor) },
#if ENABLE(CSP_NEXT)
    { "SecurityPolicyViolationEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSecurityPolicyViolationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSecurityPolicyViolationEventConstructor) },
#endif
#if ENABLE(SHADOW_DOM)
    { "WebKitShadowRoot", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitShadowRootConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitShadowRootConstructor) },
#endif
    { "Text", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextConstructor) },
    { "TextEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextEventConstructor) },
#if ENABLE(TOUCH_EVENTS)
    { "Touch", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTouchConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTouchConstructor) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "TouchEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTouchEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTouchEventConstructor) },
#endif
#if ENABLE(TOUCH_EVENTS)
    { "TouchList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTouchListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTouchListConstructor) },
#endif
    { "TransitionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTransitionEventConstructor) },
    { "TreeWalker", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTreeWalkerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTreeWalkerConstructor) },
    { "UIEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowUIEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowUIEventConstructor) },
    { "WebKitAnimationEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitAnimationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitAnimationEventConstructor) },
    { "WebKitTransitionEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitTransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitTransitionEventConstructor) },
    { "WheelEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWheelEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWheelEventConstructor) },
    { "Blob", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowBlobConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowBlobConstructor) },
    { "File", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFileConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFileConstructor) },
#if ENABLE(BLOB)
    { "FileError", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFileErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFileErrorConstructor) },
#endif
    { "FileList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFileListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFileListConstructor) },
#if ENABLE(BLOB)
    { "FileReader", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFileReaderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFileReaderConstructor) },
#endif
    { "FormData", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowFormDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowFormDataConstructor) },
    { "DOMSettableTokenList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMSettableTokenListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMSettableTokenListConstructor) },
    { "DOMTokenList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMTokenListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMTokenListConstructor) },
    { "URL", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowURLConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowURLConstructor) },
    { "HTMLAllCollection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLAllCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLAllCollectionConstructor) },
    { "HTMLAnchorElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLAnchorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLAnchorElementConstructor) },
    { "HTMLAppletElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLAppletElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLAppletElementConstructor) },
    { "HTMLAreaElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLAreaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLAreaElementConstructor) },
#if ENABLE(VIDEO)
    { "HTMLAudioElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLAudioElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLAudioElementConstructor) },
#endif
#if ENABLE(VIDEO)
    { "Audio", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowAudioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowAudioConstructor) },
#endif
    { "HTMLBRElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLBRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLBRElementConstructor) },
    { "HTMLBaseElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLBaseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLBaseElementConstructor) },
    { "HTMLBaseFontElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLBaseFontElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLBaseFontElementConstructor) },
    { "HTMLBodyElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLBodyElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLBodyElementConstructor) },
    { "HTMLButtonElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLButtonElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLButtonElementConstructor) },
    { "HTMLCanvasElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLCanvasElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLCanvasElementConstructor) },
    { "HTMLCollection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLCollectionConstructor) },
    { "HTMLDListElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLDListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLDListElementConstructor) },
#if ENABLE(DATALIST_ELEMENT)
    { "HTMLDataListElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLDataListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLDataListElementConstructor) },
#endif
    { "HTMLDirectoryElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLDirectoryElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLDirectoryElementConstructor) },
    { "HTMLDivElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLDivElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLDivElementConstructor) },
    { "HTMLDocument", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLDocumentConstructor) },
    { "HTMLElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLElementConstructor) },
    { "HTMLEmbedElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLEmbedElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLEmbedElementConstructor) },
    { "HTMLFieldSetElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFieldSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFieldSetElementConstructor) },
    { "HTMLFontElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFontElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFontElementConstructor) },
    { "HTMLFormControlsCollection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFormControlsCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFormControlsCollectionConstructor) },
    { "HTMLFormElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFormElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFormElementConstructor) },
    { "HTMLFrameElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFrameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFrameElementConstructor) },
    { "HTMLFrameSetElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLFrameSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLFrameSetElementConstructor) },
    { "HTMLHRElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLHRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLHRElementConstructor) },
    { "HTMLHeadElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLHeadElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLHeadElementConstructor) },
    { "HTMLHeadingElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLHeadingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLHeadingElementConstructor) },
    { "HTMLHtmlElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLHtmlElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLHtmlElementConstructor) },
    { "HTMLIFrameElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLIFrameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLIFrameElementConstructor) },
    { "HTMLImageElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLImageElementConstructor) },
    { "HTMLInputElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLInputElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLInputElementConstructor) },
    { "HTMLKeygenElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLKeygenElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLKeygenElementConstructor) },
    { "HTMLLIElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLLIElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLLIElementConstructor) },
    { "HTMLLabelElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLLabelElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLLabelElementConstructor) },
    { "HTMLLegendElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLLegendElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLLegendElementConstructor) },
    { "HTMLLinkElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLLinkElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLLinkElementConstructor) },
    { "HTMLMapElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMapElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMapElementConstructor) },
    { "HTMLMarqueeElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMarqueeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMarqueeElementConstructor) },
#if ENABLE(VIDEO)
    { "HTMLMediaElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMediaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMediaElementConstructor) },
#endif
    { "HTMLMenuElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMenuElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMenuElementConstructor) },
    { "HTMLMetaElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMetaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMetaElementConstructor) },
#if ENABLE(METER_ELEMENT)
    { "HTMLMeterElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLMeterElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLMeterElementConstructor) },
#endif
    { "HTMLModElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLModElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLModElementConstructor) },
    { "HTMLOListElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLOListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLOListElementConstructor) },
    { "HTMLObjectElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLObjectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLObjectElementConstructor) },
    { "HTMLOptGroupElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLOptGroupElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLOptGroupElementConstructor) },
    { "HTMLOptionElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLOptionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLOptionElementConstructor) },
    { "Option", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowOptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowOptionConstructor) },
    { "HTMLOptionsCollection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLOptionsCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLOptionsCollectionConstructor) },
    { "HTMLOutputElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLOutputElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLOutputElementConstructor) },
    { "HTMLParagraphElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLParagraphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLParagraphElementConstructor) },
    { "HTMLParamElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLParamElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLParamElementConstructor) },
    { "HTMLPreElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLPreElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLPreElementConstructor) },
#if ENABLE(PROGRESS_ELEMENT)
    { "HTMLProgressElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLProgressElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLProgressElementConstructor) },
#endif
    { "HTMLQuoteElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLQuoteElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLQuoteElementConstructor) },
    { "HTMLScriptElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLScriptElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLScriptElementConstructor) },
    { "HTMLSelectElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLSelectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLSelectElementConstructor) },
#if ENABLE(VIDEO)
    { "HTMLSourceElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLSourceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLSourceElementConstructor) },
#endif
    { "HTMLSpanElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLSpanElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLSpanElementConstructor) },
    { "HTMLStyleElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLStyleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLStyleElementConstructor) },
    { "HTMLTableCaptionElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableCaptionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableCaptionElementConstructor) },
    { "HTMLTableCellElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableCellElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableCellElementConstructor) },
    { "HTMLTableColElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableColElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableColElementConstructor) },
    { "HTMLTableElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableElementConstructor) },
    { "HTMLTableRowElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableRowElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableRowElementConstructor) },
    { "HTMLTableSectionElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTableSectionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTableSectionElementConstructor) },
#if ENABLE(TEMPLATE_ELEMENT)
    { "HTMLTemplateElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTemplateElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTemplateElementConstructor) },
#endif
    { "HTMLTextAreaElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTextAreaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTextAreaElementConstructor) },
    { "HTMLTitleElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTitleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTitleElementConstructor) },
#if ENABLE(VIDEO_TRACK)
    { "HTMLTrackElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLTrackElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLTrackElementConstructor) },
#endif
    { "HTMLUListElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLUListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLUListElementConstructor) },
    { "HTMLUnknownElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLUnknownElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLUnknownElementConstructor) },
#if ENABLE(VIDEO)
    { "HTMLVideoElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHTMLVideoElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHTMLVideoElementConstructor) },
#endif
    { "ImageData", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowImageDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowImageDataConstructor) },
#if ENABLE(VIDEO)
    { "MediaController", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaControllerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaControllerConstructor) },
#endif
#if ENABLE(VIDEO)
    { "MediaError", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaErrorConstructor) },
#endif
#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
    { "WebKitMediaKeyError", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitMediaKeyErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitMediaKeyErrorConstructor) },
#endif
#if ENABLE(ENCRYPTED_MEDIA)
    { "MediaKeyEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMediaKeyEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMediaKeyEventConstructor) },
#endif
    { "TextMetrics", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextMetricsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextMetricsConstructor) },
#if ENABLE(VIDEO)
    { "TimeRanges", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTimeRangesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTimeRangesConstructor) },
#endif
    { "CanvasGradient", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCanvasGradientConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCanvasGradientConstructor) },
    { "CanvasPattern", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCanvasPatternConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCanvasPatternConstructor) },
#if ENABLE(CANVAS_PROXY)
    { "CanvasProxy", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCanvasProxyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCanvasProxyConstructor) },
#endif
    { "CanvasRenderingContext2D", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowCanvasRenderingContext2DConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowCanvasRenderingContext2DConstructor) },
#if ENABLE(CANVAS_PATH)
    { "Path", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPathConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPathConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLActiveInfo", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLActiveInfoConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLActiveInfoConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLBuffer", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLBufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLBufferConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLContextEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLContextEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLContextEventConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLFramebuffer", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLFramebufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLFramebufferConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLProgram", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLProgramConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLProgramConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLRenderbuffer", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLRenderbufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLRenderbufferConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLRenderingContext", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLRenderingContextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLRenderingContextConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLShader", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLShaderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLShaderConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLShaderPrecisionFormat", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLShaderPrecisionFormatConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLShaderPrecisionFormatConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLTexture", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLTextureConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLTextureConstructor) },
#endif
#if ENABLE(WEBGL)
    { "WebGLUniformLocation", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebGLUniformLocationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebGLUniformLocationConstructor) },
#endif
#if ENABLE(VIDEO_TRACK)
    { "TextTrack", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextTrackConstructor) },
#endif
#if ENABLE(VIDEO_TRACK)
    { "TextTrackCue", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextTrackCueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextTrackCueConstructor) },
#endif
#if ENABLE(VIDEO_TRACK)
    { "TextTrackCueList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextTrackCueListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextTrackCueListConstructor) },
#endif
#if ENABLE(VIDEO_TRACK)
    { "TextTrackList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTextTrackListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTextTrackListConstructor) },
#endif
#if ENABLE(VIDEO_TRACK)
    { "TrackEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTrackEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowTrackEventConstructor) },
#endif
    { "BarProp", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowBarPropConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowBarPropConstructor) },
#if ENABLE(CSP_NEXT)
    { "SecurityPolicy", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSecurityPolicyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSecurityPolicyConstructor) },
#endif
    { "Selection", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSelectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSelectionConstructor) },
    { "Window", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWindowConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWindowConstructor) },
    { "EventSource", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowEventSourceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowEventSourceConstructor) },
    { "History", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowHistoryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowHistoryConstructor) },
    { "Location", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowLocationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowLocationConstructor) },
    { "Navigator", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowNavigatorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowNavigatorConstructor) },
#if ENABLE(WEB_TIMING)
    { "Performance", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceConstructor) },
#endif
#if ENABLE(PERFORMANCE_TIMELINE)
    { "PerformanceEntry", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceEntryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceEntryConstructor) },
#endif
#if ENABLE(USER_TIMING)
    { "PerformanceMark", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceMarkConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceMarkConstructor) },
#endif
#if ENABLE(USER_TIMING)
    { "PerformanceMeasure", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceMeasureConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceMeasureConstructor) },
#endif
#if ENABLE(WEB_TIMING)
    { "PerformanceNavigation", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceNavigationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceNavigationConstructor) },
#endif
#if ENABLE(RESOURCE_TIMING)
    { "PerformanceResourceTiming", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceResourceTimingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceResourceTimingConstructor) },
#endif
#if ENABLE(WEB_TIMING)
    { "PerformanceTiming", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPerformanceTimingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPerformanceTimingConstructor) },
#endif
    { "Screen", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowScreenConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowScreenConstructor) },
#if ENABLE(INPUT_SPEECH)
    { "SpeechInputEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSpeechInputEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSpeechInputEventConstructor) },
#endif
    { "WebKitPoint", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebKitPointConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWebKitPointConstructor) },
    { "MimeType", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMimeTypeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMimeTypeConstructor) },
    { "MimeTypeArray", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowMimeTypeArrayConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowMimeTypeArrayConstructor) },
    { "Plugin", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPluginConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPluginConstructor) },
    { "PluginArray", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPluginArrayConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowPluginArrayConstructor) },
    { "Storage", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStorageConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStorageConstructor) },
    { "StorageEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowStorageEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowStorageEventConstructor) },
#if ENABLE(SVG)
    { "SVGAElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGAltGlyphDefElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAltGlyphDefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAltGlyphDefElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGAltGlyphElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAltGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAltGlyphElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGAltGlyphItemElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAltGlyphItemElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAltGlyphItemElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAngle", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAngleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAngleConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimateColorElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimateColorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimateColorElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimateElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimateElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimateElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimateMotionElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimateMotionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimateMotionElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimateTransformElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimateTransformElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimateTransformElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedAngle", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedAngleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedAngleConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedBoolean", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedBooleanConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedBooleanConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedEnumeration", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedEnumerationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedEnumerationConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedInteger", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedIntegerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedIntegerConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedLength", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedLengthConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedLengthConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedLengthList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedLengthListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedLengthListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedNumber", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedNumberConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedNumberConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedNumberList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedNumberListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedNumberListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedPreserveAspectRatio", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedPreserveAspectRatioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedPreserveAspectRatioConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedRect", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedRectConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedString", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedStringConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedStringConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimatedTransformList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimatedTransformListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimatedTransformListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGAnimationElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGAnimationElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGAnimationElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGCircleElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGCircleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGCircleElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGClipPathElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGClipPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGClipPathElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGColor", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGColorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGColorConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGComponentTransferFunctionElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGComponentTransferFunctionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGComponentTransferFunctionElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGCursorElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGCursorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGCursorElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGDefsElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGDefsElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGDefsElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGDescElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGDescElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGDescElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGDocument", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGDocumentConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGElementInstance", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGElementInstanceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGElementInstanceConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGElementInstanceList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGElementInstanceListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGElementInstanceListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGEllipseElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGEllipseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGEllipseElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGExceptionConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEBlendElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEBlendElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEBlendElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEColorMatrixElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEColorMatrixElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEColorMatrixElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEComponentTransferElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEComponentTransferElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEComponentTransferElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFECompositeElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFECompositeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFECompositeElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEConvolveMatrixElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEConvolveMatrixElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEConvolveMatrixElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEDiffuseLightingElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEDiffuseLightingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEDiffuseLightingElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEDisplacementMapElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEDisplacementMapElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEDisplacementMapElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEDistantLightElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEDistantLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEDistantLightElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEDropShadowElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEDropShadowElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEDropShadowElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEFloodElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEFloodElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEFloodElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEFuncAElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEFuncAElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEFuncAElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEFuncBElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEFuncBElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEFuncBElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEFuncGElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEFuncGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEFuncGElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEFuncRElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEFuncRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEFuncRElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEGaussianBlurElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEGaussianBlurElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEGaussianBlurElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEImageElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEImageElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEMergeElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEMergeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEMergeElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEMergeNodeElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEMergeNodeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEMergeNodeElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEMorphologyElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEMorphologyElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEMorphologyElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEOffsetElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEOffsetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEOffsetElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFEPointLightElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFEPointLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFEPointLightElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFESpecularLightingElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFESpecularLightingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFESpecularLightingElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFESpotLightElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFESpotLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFESpotLightElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFETileElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFETileElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFETileElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFETurbulenceElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFETurbulenceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFETurbulenceElementConstructor) },
#endif
#if ENABLE(FILTERS) && ENABLE(SVG)
    { "SVGFilterElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFilterElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFilterElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontFaceElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontFaceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontFaceElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontFaceFormatElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontFaceFormatElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontFaceFormatElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontFaceNameElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontFaceNameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontFaceNameElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontFaceSrcElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontFaceSrcElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontFaceSrcElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGFontFaceUriElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGFontFaceUriElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGFontFaceUriElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGForeignObjectElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGForeignObjectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGForeignObjectElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGGElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGGElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGGlyphElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGGlyphElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGGlyphRefElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGGlyphRefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGGlyphRefElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGGradientElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGGradientElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGGraphicsElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGGraphicsElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGGraphicsElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGHKernElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGHKernElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGHKernElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGImageElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGImageElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGLength", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGLengthConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGLengthConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGLengthList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGLengthListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGLengthListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGLineElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGLineElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGLineElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGLinearGradientElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGLinearGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGLinearGradientElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGMPathElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMPathElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGMarkerElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMarkerElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMarkerElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGMaskElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMaskElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMaskElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGMatrix", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMatrixConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMatrixConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGMetadataElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMetadataElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMetadataElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGMissingGlyphElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGMissingGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGMissingGlyphElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGNumber", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGNumberConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGNumberConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGNumberList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGNumberListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGNumberListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPaint", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPaintConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPaintConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSeg", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegArcAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegArcAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegArcAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegArcRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegArcRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegArcRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegClosePath", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegClosePathConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegClosePathConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoCubicAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoCubicAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoCubicAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoCubicRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoCubicRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoCubicRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoCubicSmoothAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoCubicSmoothAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoCubicSmoothAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoCubicSmoothRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoCubicSmoothRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoCubicSmoothRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoQuadraticAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoQuadraticAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoQuadraticAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoQuadraticRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoQuadraticRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoQuadraticRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoQuadraticSmoothAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoQuadraticSmoothAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegCurvetoQuadraticSmoothRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegCurvetoQuadraticSmoothRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoHorizontalAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoHorizontalAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoHorizontalAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoHorizontalRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoHorizontalRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoHorizontalRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoVerticalAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoVerticalAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoVerticalAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegLinetoVerticalRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegLinetoVerticalRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegLinetoVerticalRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegMovetoAbs", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegMovetoAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegMovetoAbsConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPathSegMovetoRel", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPathSegMovetoRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPathSegMovetoRelConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPatternElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPatternElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPatternElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPoint", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPointConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPointConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPointList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPointListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPointListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPolygonElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPolygonElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPolygonElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPolylineElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPolylineElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPolylineElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGPreserveAspectRatio", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGPreserveAspectRatioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGPreserveAspectRatioConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGRadialGradientElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGRadialGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGRadialGradientElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGRect", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGRectConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGRectElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGRectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGRectElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGRenderingIntent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGRenderingIntentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGRenderingIntentConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGSVGElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGSVGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGSVGElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGScriptElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGScriptElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGScriptElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGSetElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGSetElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGStopElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGStopElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGStopElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGStringList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGStringListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGStringListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGStyleElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGStyleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGStyleElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGSwitchElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGSwitchElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGSwitchElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGSymbolElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGSymbolElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGSymbolElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTRefElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTRefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTRefElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTSpanElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTSpanElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTSpanElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTextContentElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTextContentElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTextContentElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTextElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTextElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTextElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTextPathElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTextPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTextPathElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTextPositioningElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTextPositioningElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTextPositioningElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTitleElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTitleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTitleElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTransform", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTransformConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTransformConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGTransformList", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGTransformListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGTransformListConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGUnitTypes", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGUnitTypesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGUnitTypesConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGUseElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGUseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGUseElementConstructor) },
#endif
#if ENABLE(SVG) && ENABLE(SVG_FONTS)
    { "SVGVKernElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGVKernElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGVKernElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGViewElement", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGViewElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGViewElementConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGViewSpec", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGViewSpecConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGViewSpecConstructor) },
#endif
#if ENABLE(SVG)
    { "SVGZoomEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSVGZoomEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSVGZoomEventConstructor) },
#endif
#if ENABLE(SHARED_WORKERS)
    { "SharedWorker", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowSharedWorkerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowSharedWorkerConstructor) },
#endif
    { "Worker", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWorkerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowWorkerConstructor) },
    { "DOMParser", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowDOMParserConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowDOMParserConstructor) },
    { "XMLHttpRequest", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLHttpRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLHttpRequestConstructor) },
    { "XMLHttpRequestException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLHttpRequestExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLHttpRequestExceptionConstructor) },
    { "XMLHttpRequestProgressEvent", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLHttpRequestProgressEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLHttpRequestProgressEventConstructor) },
    { "XMLHttpRequestUpload", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLHttpRequestUploadConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLHttpRequestUploadConstructor) },
    { "XMLSerializer", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXMLSerializerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXMLSerializerConstructor) },
    { "XPathEvaluator", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXPathEvaluatorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXPathEvaluatorConstructor) },
    { "XPathException", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXPathExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXPathExceptionConstructor) },
    { "XPathExpression", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXPathExpressionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXPathExpressionConstructor) },
    { "XPathResult", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXPathResultConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXPathResultConstructor) },
#if ENABLE(XSLT)
    { "XSLTProcessor", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowXSLTProcessorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowXSLTProcessorConstructor) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "webkitIndexedDB", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitIndexedDB), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
#endif
#if ENABLE(INDEXED_DATABASE)
    { "indexedDB", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowIndexedDB), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
#endif
#if ENABLE(QUOTA)
    { "webkitStorageInfo", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowWebkitStorageInfo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
#endif
    { "constructor", DontEnum | DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindowConstructor) },
    { 0, 0, NoIntrinsic, 0, 0 }
};

static const HashTable JSDOMWindowTable = { 2128, 2047, true, JSDOMWindowTableValues, 0 };
/* Hash table for constructor */

static const HashTableValue JSDOMWindowConstructorTableValues[] =
{
    { 0, 0, NoIntrinsic, 0, 0 }
};

static const HashTable JSDOMWindowConstructorTable = { 1, 0, false, JSDOMWindowConstructorTableValues, 0 };
const ClassInfo JSDOMWindowConstructor::s_info = { "WindowConstructor", &Base::s_info, &JSDOMWindowConstructorTable, 0, CREATE_METHOD_TABLE(JSDOMWindowConstructor) };

JSDOMWindowConstructor::JSDOMWindowConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
    : DOMConstructorObject(structure, globalObject)
{
}

void JSDOMWindowConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
{
    Base::finishCreation(vm);
    ASSERT(inherits(info()));
    putDirect(vm, vm.propertyNames->prototype, globalObject->prototype(), DontDelete | ReadOnly);
    putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontDelete | DontEnum);
}

bool JSDOMWindowConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
    return getStaticValueSlot<JSDOMWindowConstructor, JSDOMWrapper>(exec, JSDOMWindowConstructorTable, jsCast<JSDOMWindowConstructor*>(object), propertyName, slot);
}

/* Hash table for prototype */

static const HashTableValue JSDOMWindowPrototypeTableValues[] =
{
    { "getSelection", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionGetSelection), (intptr_t) (0) },
    { "focus", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionFocus), (intptr_t) (0) },
    { "blur", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionBlur), (intptr_t) (0) },
    { "close", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionClose), (intptr_t) (0) },
    { "print", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionPrint), (intptr_t) (0) },
    { "stop", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionStop), (intptr_t) (0) },
    { "open", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionOpen), (intptr_t) (2) },
    { "showModalDialog", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionShowModalDialog), (intptr_t) (1) },
    { "alert", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionAlert), (intptr_t) (0) },
    { "confirm", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionConfirm), (intptr_t) (0) },
    { "prompt", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionPrompt), (intptr_t) (0) },
    { "find", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionFind), (intptr_t) (0) },
    { "scrollBy", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionScrollBy), (intptr_t) (0) },
    { "scrollTo", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionScrollTo), (intptr_t) (0) },
    { "scroll", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionScroll), (intptr_t) (0) },
    { "moveBy", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionMoveBy), (intptr_t) (0) },
    { "moveTo", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionMoveTo), (intptr_t) (0) },
    { "resizeBy", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionResizeBy), (intptr_t) (0) },
    { "resizeTo", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionResizeTo), (intptr_t) (0) },
    { "matchMedia", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionMatchMedia), (intptr_t) (1) },
    { "getComputedStyle", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionGetComputedStyle), (intptr_t) (0) },
    { "getMatchedCSSRules", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionGetMatchedCSSRules), (intptr_t) (0) },
    { "webkitConvertPointFromPageToNode", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionWebkitConvertPointFromPageToNode), (intptr_t) (0) },
    { "webkitConvertPointFromNodeToPage", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionWebkitConvertPointFromNodeToPage), (intptr_t) (0) },
    { "postMessage", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionPostMessage), (intptr_t) (2) },
    { "requestAnimationFrame", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionRequestAnimationFrame), (intptr_t) (1) },
    { "cancelAnimationFrame", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionCancelAnimationFrame), (intptr_t) (1) },
    { "webkitRequestAnimationFrame", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionWebkitRequestAnimationFrame), (intptr_t) (1) },
    { "webkitCancelAnimationFrame", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionWebkitCancelAnimationFrame), (intptr_t) (1) },
    { "webkitCancelRequestAnimationFrame", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionWebkitCancelRequestAnimationFrame), (intptr_t) (1) },
    { "addEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionAddEventListener), (intptr_t) (2) },
    { "removeEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionRemoveEventListener), (intptr_t) (2) },
    { "dispatchEvent", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionDispatchEvent), (intptr_t) (1) },
    { "captureEvents", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionCaptureEvents), (intptr_t) (0) },
    { "releaseEvents", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionReleaseEvents), (intptr_t) (0) },
#if ENABLE(SQL_DATABASE)
    { "openDatabase", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionOpenDatabase), (intptr_t) (4) },
#endif
    { "atob", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionAtob), (intptr_t) (1) },
    { "btoa", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionBtoa), (intptr_t) (1) },
    { "setTimeout", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionSetTimeout), (intptr_t) (1) },
    { "clearTimeout", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionClearTimeout), (intptr_t) (0) },
    { "setInterval", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionSetInterval), (intptr_t) (1) },
    { "clearInterval", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsDOMWindowPrototypeFunctionClearInterval), (intptr_t) (0) },
    { 0, 0, NoIntrinsic, 0, 0 }
};

static const HashTable JSDOMWindowPrototypeTable = { 136, 127, false, JSDOMWindowPrototypeTableValues, 0 };
const ClassInfo JSDOMWindowPrototype::s_info = { "WindowPrototype", &Base::s_info, &JSDOMWindowPrototypeTable, 0, CREATE_METHOD_TABLE(JSDOMWindowPrototype) };

bool JSDOMWindowPrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
    JSDOMWindowPrototype* thisObject = jsCast<JSDOMWindowPrototype*>(object);
    return getStaticFunctionSlot<JSObject>(exec, JSDOMWindowPrototypeTable, thisObject, propertyName, slot);
}

const ClassInfo JSDOMWindow::s_info = { "Window", &Base::s_info, &JSDOMWindowTable, 0 , CREATE_METHOD_TABLE(JSDOMWindow) };

JSDOMWindow::JSDOMWindow(VM& vm, Structure* structure, PassRefPtr<DOMWindow> impl, JSDOMWindowShell* shell)
    : JSDOMWindowBase(vm, structure, impl, shell)
{
}

EncodedJSValue jsDOMWindowScreen(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.screen()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowHistory(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.history()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowLocationbar(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.locationbar()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowMenubar(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.menubar()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowPersonalbar(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.personalbar()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScrollbars(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.scrollbars()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowStatusbar(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.statusbar()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowToolbar(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.toolbar()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowNavigator(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.navigator()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowClientInformation(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.clientInformation()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowCrypto(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.crypto()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowLocation(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.location()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowEvent(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->event(exec));
}


EncodedJSValue jsDOMWindowFrameElement(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    return JSValue::encode(shouldAllowAccessToNode(exec, impl.frameElement()) ? toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.frameElement())) : jsNull());
}


EncodedJSValue jsDOMWindowOffscreenBuffering(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsBoolean(impl.offscreenBuffering());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowOuterHeight(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.outerHeight());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowOuterWidth(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.outerWidth());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowInnerHeight(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.innerHeight());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowInnerWidth(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.innerWidth());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScreenX(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.screenX());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScreenY(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.screenY());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScreenLeft(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.screenLeft());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScreenTop(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.screenTop());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScrollX(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.scrollX());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowScrollY(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.scrollY());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowPageXOffset(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.pageXOffset());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowPageYOffset(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.pageYOffset());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowClosed(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsBoolean(impl.closed());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowLength(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.length());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowName(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsStringWithCache(exec, impl.name());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowStatus(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsStringWithCache(exec, impl.status());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowDefaultStatus(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsStringWithCache(exec, impl.defaultStatus());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowDefaultstatus(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsStringWithCache(exec, impl.defaultStatus());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowSelf(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.self()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowWindow(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.window()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowFrames(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.frames()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowOpener(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.opener()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowParent(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.parent()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowTop(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.top()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowDocument(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.document()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowStyleMedia(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.styleMedia()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowDevicePixelRatio(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = jsNumber(impl.devicePixelRatio());
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowApplicationCache(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.applicationCache()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowSessionStorage(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    ExceptionCode ec = 0;
    DOMWindow& impl = castedThis->impl();
    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.sessionStorage(ec)));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowLocalStorage(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    ExceptionCode ec = 0;
    DOMWindow& impl = castedThis->impl();
    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.localStorage(ec)));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowConsole(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.console()));
    return JSValue::encode(result);
}


EncodedJSValue jsDOMWindowPerformance(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.performance()));
    return JSValue::encode(result);
}


#if ENABLE(CSS3_CONDITIONAL_RULES)
EncodedJSValue jsDOMWindowCSS(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.css()));
    return JSValue::encode(result);
}

#endif

EncodedJSValue jsDOMWindowOnabort(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onabort()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnbeforeunload(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onbeforeunload()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnblur(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onblur()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOncanplay(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.oncanplay()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOncanplaythrough(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.oncanplaythrough()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnchange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onchange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnclick(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onclick()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOncontextmenu(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.oncontextmenu()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndblclick(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondblclick()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndrag(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondrag()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndragend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondragend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndragenter(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondragenter()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndragleave(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondragleave()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndragover(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondragover()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndragstart(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondragstart()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndrop(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondrop()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOndurationchange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondurationchange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnemptied(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onemptied()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnended(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onended()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnerror(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onerror()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnfocus(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onfocus()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnhashchange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onhashchange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOninput(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.oninput()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOninvalid(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.oninvalid()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnkeydown(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onkeydown()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnkeypress(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onkeypress()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnkeyup(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onkeyup()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnload(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onload()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnloadeddata(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onloadeddata()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnloadedmetadata(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onloadedmetadata()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnloadstart(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onloadstart()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmessage(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmessage()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmousedown(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmousedown()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmouseenter(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmouseenter()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmouseleave(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmouseleave()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmousemove(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmousemove()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmouseout(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmouseout()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmouseover(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmouseover()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmouseup(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmouseup()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnmousewheel(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onmousewheel()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnoffline(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onoffline()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnonline(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ononline()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnpagehide(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onpagehide()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnpageshow(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onpageshow()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnpause(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onpause()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnplay(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onplay()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnplaying(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onplaying()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnpopstate(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onpopstate()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnprogress(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onprogress()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnratechange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onratechange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnresize(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onresize()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnscroll(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onscroll()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnseeked(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onseeked()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnseeking(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onseeking()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnselect(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onselect()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnstalled(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onstalled()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnstorage(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onstorage()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnsubmit(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onsubmit()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnsuspend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onsuspend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOntimeupdate(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontimeupdate()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnunload(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onunload()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnvolumechange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onvolumechange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwaiting(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwaiting()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwheel(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwheel()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnreset(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onreset()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnsearch(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onsearch()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwebkitanimationend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwebkitanimationend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwebkitanimationiteration(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwebkitanimationiteration()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwebkitanimationstart(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwebkitanimationstart()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOnwebkittransitionend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwebkittransitionend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


EncodedJSValue jsDOMWindowOntransitionend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontransitionend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}


#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowOntouchstart(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontouchstart()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowOntouchmove(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontouchmove()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowOntouchend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontouchend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowOntouchcancel(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ontouchcancel()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
EncodedJSValue jsDOMWindowOngesturestart(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ongesturestart()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
EncodedJSValue jsDOMWindowOngesturechange(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ongesturechange()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
EncodedJSValue jsDOMWindowOngestureend(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ongestureend()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
EncodedJSValue jsDOMWindowOndevicemotion(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondevicemotion()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
EncodedJSValue jsDOMWindowOndeviceorientation(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.ondeviceorientation()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

#if ENABLE(PROXIMITY_EVENTS)
EncodedJSValue jsDOMWindowOnwebkitdeviceproximity(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    if (EventListener* listener = impl.onwebkitdeviceproximity()) {
        if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {
            if (JSObject* jsFunction = jsListener->jsFunction(impl.scriptExecutionContext()))
                return JSValue::encode(jsFunction);
        }
    }
    return JSValue::encode(jsNull());
}

#endif

EncodedJSValue jsDOMWindowImageConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->image(exec));
}


EncodedJSValue jsDOMWindowXMLDocumentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDocument::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(IOS_TOUCH_EVENTS)
EncodedJSValue jsDOMWindowTouchConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->touch(exec));
}

#endif

#if ENABLE(IOS_TOUCH_EVENTS)
EncodedJSValue jsDOMWindowTouchListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->touchList(exec));
}

#endif

#if ENABLE(BLOB)
EncodedJSValue jsDOMWindowWebkitURLConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMURL::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowWebKitMutationObserverConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMutationObserver::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBCursorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBCursor::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBDatabaseConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBDatabase::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBFactoryConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBFactory::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBIndexConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBIndex::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBKeyRangeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBKeyRange::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBObjectStoreConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBObjectStore::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBRequestConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBRequest::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIDBTransactionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBTransaction::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBCursorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBCursor::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBCursorWithValueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBCursorWithValue::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBDatabaseConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBDatabase::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBFactoryConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBFactory::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBIndexConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBIndex::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBKeyRangeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBKeyRange::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBObjectStoreConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBObjectStore::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBOpenDBRequestConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBOpenDBRequest::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBRequestConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBRequest::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBTransactionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBTransaction::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIDBVersionChangeEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSIDBVersionChangeEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_SOURCE)
EncodedJSValue jsDOMWindowMediaSourceConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!castedThis->impl().frame())
        return JSValue::encode(jsUndefined());
    Settings& settings = castedThis->impl().frame()->settings();
    if (!settings.mediaSourceEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaSource::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowAudioStreamTrackConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioStreamTrack::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowWebkitMediaStreamConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStream::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowMediaStreamEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStreamEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowMediaStreamTrackConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStreamTrack::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowMediaStreamTrackEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStreamTrackEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowRTCIceCandidateConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRTCIceCandidate::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowWebkitRTCPeerConnectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRTCPeerConnection::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowRTCSessionDescriptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRTCSessionDescription::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM)
EncodedJSValue jsDOMWindowVideoStreamTrackConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSVideoStreamTrack::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
EncodedJSValue jsDOMWindowNotificationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNotification::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(PROXIMITY_EVENTS)
EncodedJSValue jsDOMWindowDeviceProximityEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDeviceProximityEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAnalyserNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAnalyserNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioBufferConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioBuffer::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioBufferSourceNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioBufferSourceNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowWebkitAudioContextConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!castedThis->impl().frame())
        return JSValue::encode(jsUndefined());
    Settings& settings = castedThis->impl().frame()->settings();
    if (!settings.webAudioEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioContext::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioDestinationNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioDestinationNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioListenerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioListener::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioParamConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioParam::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowAudioProcessingEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAudioProcessingEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowBiquadFilterNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSBiquadFilterNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowChannelMergerNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSChannelMergerNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowChannelSplitterNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSChannelSplitterNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowConvolverNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSConvolverNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowDelayNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDelayNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowDynamicsCompressorNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDynamicsCompressorNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowGainNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSGainNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowMediaElementAudioSourceNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaElementAudioSourceNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowMediaStreamAudioDestinationNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStreamAudioDestinationNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowMediaStreamAudioSourceNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaStreamAudioSourceNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowOfflineAudioCompletionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSOfflineAudioCompletionEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowWebkitOfflineAudioContextConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSOfflineAudioContext::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowOscillatorNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSOscillatorNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowWebkitAudioPannerNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPannerNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowPeriodicWaveConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPeriodicWave::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowScriptProcessorNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSScriptProcessorNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_AUDIO)
EncodedJSValue jsDOMWindowWaveShaperNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWaveShaperNode::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SQL_DATABASE)
EncodedJSValue jsDOMWindowSQLExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSQLException::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowCloseEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCloseEvent::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(WEB_SOCKETS)
EncodedJSValue jsDOMWindowWebSocketConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!RuntimeEnabledFeatures::sharedFeatures().webSocketEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebSocket::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowCSSCharsetRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSCharsetRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSFontFaceRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSFontFaceRule::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(SHADOW_DOM)
EncodedJSValue jsDOMWindowCSSHostRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSHostRule::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowCSSImportRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSImportRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSMediaRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSMediaRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSPageRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSPageRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSPrimitiveValueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSPrimitiveValue::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSRuleListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSRuleList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSStyleDeclarationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSStyleDeclaration::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSStyleRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSStyleRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSStyleSheetConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSStyleSheet::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSValueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSValue::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCSSValueListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCSSValueList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCounterConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCounter::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMediaListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowRGBColorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRGBColor::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowRectConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRect::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowStyleSheetConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSStyleSheet::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowStyleSheetListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSStyleSheetList::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CSS_FILTERS)
EncodedJSValue jsDOMWindowWebKitCSSFilterValueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSFilterValue::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowWebKitCSSKeyframeRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSKeyframeRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWebKitCSSKeyframesRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSKeyframesRule::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWebKitCSSMatrixConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSMatrix::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CSS_REGIONS)
EncodedJSValue jsDOMWindowWebKitCSSRegionRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSRegionRule::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowWebKitCSSTransformValueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSTransformValue::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CSS_DEVICE_ADAPTATION)
EncodedJSValue jsDOMWindowWebKitCSSViewportRuleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitCSSViewportRule::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowAttrConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSAttr::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowBeforeLoadEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSBeforeLoadEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowBeforeUnloadEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSBeforeUnloadEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCDATASectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCDATASection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCharacterDataConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCharacterData::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowClientRectConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSClientRect::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowClientRectListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSClientRectList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowClipboardConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSClipboard::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCommentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSComment::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCompositionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCompositionEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCustomEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCustomEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMCoreException::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMImplementationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMImplementation::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMStringListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMStringList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMStringMapConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMStringMap::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(DEVICE_ORIENTATION)
EncodedJSValue jsDOMWindowDeviceMotionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDeviceMotionEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
EncodedJSValue jsDOMWindowDeviceOrientationEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDeviceOrientationEvent::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowDocumentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDocument::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDocumentFragmentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDocumentFragment::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDocumentTypeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDocumentType::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowEntityConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSEntity::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowEntityReferenceConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSEntityReference::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowErrorEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSErrorEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowEventExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSEventException::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowFocusEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSFocusEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHashChangeEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHashChangeEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowKeyboardEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSKeyboardEvent::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CHANNEL_MESSAGING)
EncodedJSValue jsDOMWindowMessageChannelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMessageChannel::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowMessageEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMessageEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMessagePortConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMessagePort::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMouseEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMouseEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMutationEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMutationEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMutationObserverConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMutationObserver::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMutationRecordConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMutationRecord::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNamedNodeMapConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNamedNodeMap::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNodeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNode::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNodeFilterConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNodeFilter::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNodeIteratorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNodeIterator::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNodeListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNodeList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNotationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNotation::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowOverflowEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSOverflowEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowPageTransitionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPageTransitionEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowPopStateEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPopStateEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowProcessingInstructionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSProcessingInstruction::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowProgressEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSProgressEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowRangeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRange::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowRangeExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSRangeException::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CSP_NEXT)
EncodedJSValue jsDOMWindowSecurityPolicyViolationEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSecurityPolicyViolationEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SHADOW_DOM)
EncodedJSValue jsDOMWindowWebKitShadowRootConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSShadowRoot::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowTextConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSText::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowTextEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextEvent::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowTouchConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTouch::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowTouchEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTouchEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(TOUCH_EVENTS)
EncodedJSValue jsDOMWindowTouchListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTouchList::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowTransitionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTransitionEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowTreeWalkerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTreeWalker::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowUIEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSUIEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWebKitAnimationEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitAnimationEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWebKitTransitionEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitTransitionEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWheelEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWheelEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowBlobConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSBlob::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowFileConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSFile::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(BLOB)
EncodedJSValue jsDOMWindowFileErrorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSFileError::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowFileListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSFileList::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(BLOB)
EncodedJSValue jsDOMWindowFileReaderConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSFileReader::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowFormDataConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMFormData::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMSettableTokenListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMSettableTokenList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMTokenListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMTokenList::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowURLConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMURL::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLAllCollectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAllCollection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLAnchorElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAnchorElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLAppletElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAppletElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLAreaElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAreaElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowHTMLAudioElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!RuntimeEnabledFeatures::sharedFeatures().htmlAudioElementEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAudioElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowAudioConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!RuntimeEnabledFeatures::sharedFeatures().audioEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLAudioElement::getNamedConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLBRElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLBRElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLBaseElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLBaseElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLBaseFontElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLBaseFontElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLBodyElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLBodyElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLButtonElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLButtonElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLCanvasElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLCanvasElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLCollectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLCollection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLDListElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLDListElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(DATALIST_ELEMENT)
EncodedJSValue jsDOMWindowHTMLDataListElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLDataListElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLDirectoryElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLDirectoryElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLDivElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLDivElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLDocumentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLDocument::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLEmbedElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLEmbedElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFieldSetElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFieldSetElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFontElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFontElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFormControlsCollectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFormControlsCollection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFormElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFormElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFrameElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFrameElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLFrameSetElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLFrameSetElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLHRElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLHRElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLHeadElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLHeadElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLHeadingElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLHeadingElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLHtmlElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLHtmlElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLIFrameElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLIFrameElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLImageElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLImageElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLInputElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLInputElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLKeygenElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLKeygenElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLLIElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLLIElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLLabelElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLLabelElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLLegendElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLLegendElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLLinkElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLLinkElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLMapElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMapElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLMarqueeElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMarqueeElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowHTMLMediaElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMediaElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLMenuElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMenuElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLMetaElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMetaElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(METER_ELEMENT)
EncodedJSValue jsDOMWindowHTMLMeterElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLMeterElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLModElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLModElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLOListElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOListElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLObjectElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLObjectElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLOptGroupElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOptGroupElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLOptionElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOptionElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowOptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOptionElement::getNamedConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLOptionsCollectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOptionsCollection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLOutputElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLOutputElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLParagraphElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLParagraphElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLParamElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLParamElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLPreElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLPreElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(PROGRESS_ELEMENT)
EncodedJSValue jsDOMWindowHTMLProgressElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLProgressElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLQuoteElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLQuoteElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLScriptElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLScriptElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLSelectElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLSelectElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowHTMLSourceElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLSourceElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLSpanElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLSpanElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLStyleElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLStyleElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableCaptionElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableCaptionElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableCellElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableCellElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableColElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableColElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableRowElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableRowElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTableSectionElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTableSectionElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(TEMPLATE_ELEMENT)
EncodedJSValue jsDOMWindowHTMLTemplateElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTemplateElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLTextAreaElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTextAreaElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLTitleElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTitleElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowHTMLTrackElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLTrackElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowHTMLUListElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLUListElement::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHTMLUnknownElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLUnknownElement::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowHTMLVideoElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHTMLVideoElement::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowImageDataConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSImageData::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowMediaControllerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaController::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowMediaErrorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaError::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
EncodedJSValue jsDOMWindowWebKitMediaKeyErrorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaKeyError::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(ENCRYPTED_MEDIA)
EncodedJSValue jsDOMWindowMediaKeyEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSMediaKeyEvent::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowTextMetricsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextMetrics::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(VIDEO)
EncodedJSValue jsDOMWindowTimeRangesConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTimeRanges::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowCanvasGradientConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCanvasGradient::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowCanvasPatternConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCanvasPattern::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CANVAS_PROXY)
EncodedJSValue jsDOMWindowCanvasProxyConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCanvasProxy::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowCanvasRenderingContext2DConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSCanvasRenderingContext2D::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CANVAS_PATH)
EncodedJSValue jsDOMWindowPathConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMPath::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLActiveInfoConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLActiveInfo::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLBufferConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLBuffer::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLContextEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLContextEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLFramebufferConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLFramebuffer::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLProgramConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLProgram::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLRenderbufferConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLRenderbuffer::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLRenderingContextConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLRenderingContext::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLShaderConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLShader::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLShaderPrecisionFormatConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLShaderPrecisionFormat::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLTextureConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLTexture::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEBGL)
EncodedJSValue jsDOMWindowWebGLUniformLocationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebGLUniformLocation::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowTextTrackConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextTrack::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowTextTrackCueConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextTrackCue::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowTextTrackCueListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextTrackCueList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowTextTrackListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTextTrackList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(VIDEO_TRACK)
EncodedJSValue jsDOMWindowTrackEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSTrackEvent::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowBarPropConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSBarProp::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(CSP_NEXT)
EncodedJSValue jsDOMWindowSecurityPolicyConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMSecurityPolicy::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowSelectionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMSelection::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowWindowConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMWindow::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowEventSourceConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSEventSource::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowHistoryConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSHistory::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowLocationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSLocation::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowNavigatorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSNavigator::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(WEB_TIMING)
EncodedJSValue jsDOMWindowPerformanceConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformance::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(PERFORMANCE_TIMELINE)
EncodedJSValue jsDOMWindowPerformanceEntryConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceEntry::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(USER_TIMING)
EncodedJSValue jsDOMWindowPerformanceMarkConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceMark::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(USER_TIMING)
EncodedJSValue jsDOMWindowPerformanceMeasureConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceMeasure::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_TIMING)
EncodedJSValue jsDOMWindowPerformanceNavigationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceNavigation::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(RESOURCE_TIMING)
EncodedJSValue jsDOMWindowPerformanceResourceTimingConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceResourceTiming::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(WEB_TIMING)
EncodedJSValue jsDOMWindowPerformanceTimingConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSPerformanceTiming::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowScreenConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSScreen::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(INPUT_SPEECH)
EncodedJSValue jsDOMWindowSpeechInputEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSpeechInputEvent::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowWebKitPointConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWebKitPoint::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMimeTypeConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMMimeType::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowMimeTypeArrayConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMMimeTypeArray::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowPluginConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMPlugin::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowPluginArrayConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMPluginArray::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowStorageConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSStorage::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowStorageEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSStorageEvent::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGAltGlyphDefElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAltGlyphDefElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGAltGlyphElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAltGlyphElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGAltGlyphItemElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAltGlyphItemElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAngleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAngle::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimateColorElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimateColorElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimateElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimateElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimateMotionElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimateMotionElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimateTransformElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimateTransformElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedAngleConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedAngle::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedBooleanConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedBoolean::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedEnumerationConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedEnumeration::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedIntegerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedInteger::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedLengthConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedLength::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedLengthListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedLengthList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedNumberConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedNumber::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedNumberListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedNumberList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedPreserveAspectRatioConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedPreserveAspectRatio::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedRectConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedRect::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedStringConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedString::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimatedTransformListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimatedTransformList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGAnimationElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGAnimationElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGCircleElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGCircleElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGClipPathElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGClipPathElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGColorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGColor::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGComponentTransferFunctionElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGComponentTransferFunctionElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGCursorElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGCursorElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGDefsElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGDefsElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGDescElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGDescElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGDocumentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGDocument::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGElementInstanceConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGElementInstance::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGElementInstanceListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGElementInstanceList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGEllipseElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGEllipseElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGException::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEBlendElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEBlendElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEColorMatrixElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEColorMatrixElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEComponentTransferElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEComponentTransferElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFECompositeElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFECompositeElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEConvolveMatrixElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEConvolveMatrixElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEDiffuseLightingElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEDiffuseLightingElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEDisplacementMapElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEDisplacementMapElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEDistantLightElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEDistantLightElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEDropShadowElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEDropShadowElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEFloodElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEFloodElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEFuncAElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEFuncAElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEFuncBElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEFuncBElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEFuncGElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEFuncGElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEFuncRElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEFuncRElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEGaussianBlurElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEGaussianBlurElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEImageElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEImageElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEMergeElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEMergeElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEMergeNodeElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEMergeNodeElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEMorphologyElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEMorphologyElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEOffsetElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEOffsetElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFEPointLightElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFEPointLightElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFESpecularLightingElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFESpecularLightingElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFESpotLightElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFESpotLightElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFETileElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFETileElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFETurbulenceElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFETurbulenceElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGFilterElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFilterElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontFaceElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontFaceElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontFaceFormatElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontFaceFormatElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontFaceNameElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontFaceNameElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontFaceSrcElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontFaceSrcElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGFontFaceUriElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGFontFaceUriElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGForeignObjectElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGForeignObjectElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGGElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGGElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGGlyphElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGGlyphElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGGlyphRefElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGGlyphRefElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGGradientElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGGradientElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGGraphicsElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGGraphicsElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGHKernElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGHKernElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGImageElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGImageElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGLengthConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGLength::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGLengthListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGLengthList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGLineElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGLineElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGLinearGradientElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGLinearGradientElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGMPathElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMPathElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGMarkerElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMarkerElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGMaskElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMaskElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGMatrixConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMatrix::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGMetadataElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMetadataElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGMissingGlyphElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGMissingGlyphElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGNumberConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGNumber::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGNumberListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGNumberList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPaintConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPaint::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSeg::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegArcAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegArcAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegArcRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegArcRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegClosePathConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegClosePath::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoCubicAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoCubicAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoCubicRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoCubicRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoCubicSmoothAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoCubicSmoothAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoCubicSmoothRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoCubicSmoothRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoQuadraticAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoQuadraticAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoQuadraticRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoQuadraticRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoQuadraticSmoothAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoQuadraticSmoothAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegCurvetoQuadraticSmoothRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegCurvetoQuadraticSmoothRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoHorizontalAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoHorizontalAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoHorizontalRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoHorizontalRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoVerticalAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoVerticalAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegLinetoVerticalRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegLinetoVerticalRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegMovetoAbsConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegMovetoAbs::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPathSegMovetoRelConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPathSegMovetoRel::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPatternElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPatternElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPointConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPoint::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPointListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPointList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPolygonElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPolygonElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPolylineElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPolylineElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGPreserveAspectRatioConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGPreserveAspectRatio::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGRadialGradientElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGRadialGradientElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGRectConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGRect::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGRectElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGRectElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGRenderingIntentConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGRenderingIntent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGSVGElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGSVGElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGScriptElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGScriptElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGSetElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGSetElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGStopElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGStopElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGStringListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGStringList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGStyleElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGStyleElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGSwitchElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGSwitchElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGSymbolElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGSymbolElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTRefElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTRefElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTSpanElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTSpanElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTextContentElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTextContentElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTextElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTextElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTextPathElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTextPathElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTextPositioningElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTextPositioningElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTitleElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTitleElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTransformConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTransform::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGTransformListConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGTransformList::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGUnitTypesConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGUnitTypes::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGUseElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGUseElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
EncodedJSValue jsDOMWindowSVGVKernElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGVKernElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGViewElementConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGViewElement::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGViewSpecConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGViewSpec::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SVG)
EncodedJSValue jsDOMWindowSVGZoomEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSVGZoomEvent::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(SHARED_WORKERS)
EncodedJSValue jsDOMWindowSharedWorkerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!RuntimeEnabledFeatures::sharedFeatures().sharedWorkerEnabled())
        return JSValue::encode(jsUndefined());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSSharedWorker::getConstructor(exec->vm(), castedThis));
}

#endif

EncodedJSValue jsDOMWindowWorkerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSWorker::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowDOMParserConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMParser::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXMLHttpRequestConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXMLHttpRequest::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXMLHttpRequestExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXMLHttpRequestException::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXMLHttpRequestProgressEventConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXMLHttpRequestProgressEvent::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXMLHttpRequestUploadConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXMLHttpRequestUpload::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXMLSerializerConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXMLSerializer::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXPathEvaluatorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXPathEvaluator::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXPathExceptionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXPathException::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXPathExpressionConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXPathExpression::getConstructor(exec->vm(), castedThis));
}


EncodedJSValue jsDOMWindowXPathResultConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXPathResult::getConstructor(exec->vm(), castedThis));
}


#if ENABLE(XSLT)
EncodedJSValue jsDOMWindowXSLTProcessorConstructor(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSXSLTProcessor::getConstructor(exec->vm(), castedThis));
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowWebkitIndexedDB(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(DOMWindowIndexedDatabase::indexedDB(&impl)));
    return JSValue::encode(result);
}

#endif

#if ENABLE(INDEXED_DATABASE)
EncodedJSValue jsDOMWindowIndexedDB(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(DOMWindowIndexedDatabase::indexedDB(&impl)));
    return JSValue::encode(result);
}

#endif

#if ENABLE(QUOTA)
EncodedJSValue jsDOMWindowWebkitStorageInfo(ExecState* exec, EncodedJSValue slotBase, EncodedJSValue thisValue, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(JSValue::decode(slotBase));
    UNUSED_PARAM(thisValue);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(DOMWindowQuota::webkitStorageInfo(&impl)));
    return JSValue::encode(result);
}

#endif

EncodedJSValue jsDOMWindowConstructor(ExecState* exec, EncodedJSValue thisValue, EncodedJSValue, PropertyName)
{
    JSDOMWindow* domObject = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!domObject) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            domObject = shell->window();
    }
    if (!domObject)
        return throwVMTypeError(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, domObject->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(JSDOMWindow::getConstructor(exec->vm(), domObject->globalObject()));
}

void setJSDOMWindowScreen(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "screen"), value);
}


void setJSDOMWindowHistory(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "history"), value);
}


void setJSDOMWindowLocationbar(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "locationbar"), value);
}


void setJSDOMWindowMenubar(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "menubar"), value);
}


void setJSDOMWindowPersonalbar(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "personalbar"), value);
}


void setJSDOMWindowScrollbars(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "scrollbars"), value);
}


void setJSDOMWindowStatusbar(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "statusbar"), value);
}


void setJSDOMWindowToolbar(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "toolbar"), value);
}


void setJSDOMWindowNavigator(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "navigator"), value);
}


void setJSDOMWindowClientInformation(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "clientInformation"), value);
}


void setJSDOMWindowLocation(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    castedThis->setLocation(exec, value);
}


void setJSDOMWindowEvent(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "event"), value);
}


void setJSDOMWindowOffscreenBuffering(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "offscreenBuffering"), value);
}


void setJSDOMWindowOuterHeight(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "outerHeight"), value);
}


void setJSDOMWindowOuterWidth(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "outerWidth"), value);
}


void setJSDOMWindowInnerHeight(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "innerHeight"), value);
}


void setJSDOMWindowInnerWidth(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "innerWidth"), value);
}


void setJSDOMWindowScreenX(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "screenX"), value);
}


void setJSDOMWindowScreenY(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "screenY"), value);
}


void setJSDOMWindowScreenLeft(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "screenLeft"), value);
}


void setJSDOMWindowScreenTop(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "screenTop"), value);
}


void setJSDOMWindowScrollX(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "scrollX"), value);
}


void setJSDOMWindowScrollY(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "scrollY"), value);
}


void setJSDOMWindowLength(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "length"), value);
}


void setJSDOMWindowName(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    DOMWindow& impl = castedThis->impl();
    const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
    if (exec->hadException())
        return;
    impl.setName(nativeValue);
}


void setJSDOMWindowStatus(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    DOMWindow& impl = castedThis->impl();
    const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
    if (exec->hadException())
        return;
    impl.setStatus(nativeValue);
}


void setJSDOMWindowDefaultStatus(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    DOMWindow& impl = castedThis->impl();
    const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
    if (exec->hadException())
        return;
    impl.setDefaultStatus(nativeValue);
}


void setJSDOMWindowDefaultstatus(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    DOMWindow& impl = castedThis->impl();
    const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
    if (exec->hadException())
        return;
    impl.setDefaultStatus(nativeValue);
}


void setJSDOMWindowSelf(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "self"), value);
}


void setJSDOMWindowFrames(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "frames"), value);
}


void setJSDOMWindowOpener(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "opener"), value);
}


void setJSDOMWindowParent(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "parent"), value);
}


void setJSDOMWindowDevicePixelRatio(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "devicePixelRatio"), value);
}


void setJSDOMWindowConsole(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "console"), value);
}


void setJSDOMWindowPerformance(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "performance"), value);
}


#if ENABLE(CSS3_CONDITIONAL_RULES)
void setJSDOMWindowCSS(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in object
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSS"), value);
}

#endif

void setJSDOMWindowOnabort(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnabort(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnbeforeunload(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnbeforeunload(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnblur(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnblur(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOncanplay(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOncanplay(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOncanplaythrough(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOncanplaythrough(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnchange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnchange(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnclick(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnclick(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOncontextmenu(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOncontextmenu(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndblclick(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndblclick(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndrag(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndrag(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndragend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndragend(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndragenter(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndragenter(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndragleave(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndragleave(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndragover(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndragover(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndragstart(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndragstart(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndrop(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndrop(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOndurationchange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndurationchange(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnemptied(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnemptied(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnended(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnended(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnerror(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnerror(createJSErrorHandler(exec, value, castedThis));
}


void setJSDOMWindowOnfocus(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnfocus(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnhashchange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnhashchange(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOninput(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOninput(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOninvalid(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOninvalid(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnkeydown(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnkeydown(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnkeypress(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnkeypress(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnkeyup(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnkeyup(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnload(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnload(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnloadeddata(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnloadeddata(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnloadedmetadata(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnloadedmetadata(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnloadstart(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnloadstart(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmessage(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmessage(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmousedown(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmousedown(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmouseenter(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmouseenter(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmouseleave(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmouseleave(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmousemove(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmousemove(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmouseout(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmouseout(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmouseover(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmouseover(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmouseup(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmouseup(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnmousewheel(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnmousewheel(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnoffline(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnoffline(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnonline(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnonline(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnpagehide(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnpagehide(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnpageshow(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnpageshow(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnpause(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnpause(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnplay(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnplay(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnplaying(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnplaying(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnpopstate(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnpopstate(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnprogress(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnprogress(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnratechange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnratechange(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnresize(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnresize(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnscroll(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnscroll(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnseeked(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnseeked(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnseeking(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnseeking(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnselect(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnselect(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnstalled(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnstalled(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnstorage(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnstorage(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnsubmit(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnsubmit(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnsuspend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnsuspend(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOntimeupdate(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntimeupdate(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnunload(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnunload(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnvolumechange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnvolumechange(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwaiting(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwaiting(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwheel(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwheel(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnreset(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnreset(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnsearch(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnsearch(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwebkitanimationend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwebkitanimationend(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwebkitanimationiteration(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwebkitanimationiteration(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwebkitanimationstart(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwebkitanimationstart(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOnwebkittransitionend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwebkittransitionend(createJSAttributeEventListener(exec, value, castedThis));
}


void setJSDOMWindowOntransitionend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntransitionend(createJSAttributeEventListener(exec, value, castedThis));
}


#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchstart(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntouchstart(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchmove(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntouchmove(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntouchend(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchcancel(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOntouchcancel(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
void setJSDOMWindowOngesturestart(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOngesturestart(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
void setJSDOMWindowOngesturechange(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOngesturechange(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(IOS_GESTURE_EVENTS)
void setJSDOMWindowOngestureend(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOngestureend(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowOndevicemotion(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndevicemotion(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowOndeviceorientation(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOndeviceorientation(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

#if ENABLE(PROXIMITY_EVENTS)
void setJSDOMWindowOnwebkitdeviceproximity(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    UNUSED_PARAM(exec);
    DOMWindow& impl = castedThis->impl();
    impl.setOnwebkitdeviceproximity(createJSAttributeEventListener(exec, value, castedThis));
}

#endif

void setJSDOMWindowImageConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Image"), value);
}


void setJSDOMWindowXMLDocumentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLDocument"), value);
}


#if ENABLE(IOS_TOUCH_EVENTS)
void setJSDOMWindowTouchConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Touch"), value);
}

#endif

#if ENABLE(IOS_TOUCH_EVENTS)
void setJSDOMWindowTouchListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TouchList"), value);
}

#endif

#if ENABLE(BLOB)
void setJSDOMWindowWebkitURLConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitURL"), value);
}

#endif

void setJSDOMWindowWebKitMutationObserverConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitMutationObserver"), value);
}


#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBCursorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBCursor"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBDatabaseConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBDatabase"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBFactoryConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBFactory"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBIndexConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBIndex"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBKeyRangeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBKeyRange"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBObjectStoreConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBObjectStore"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBRequestConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBTransactionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitIDBTransaction"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBCursorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBCursor"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBCursorWithValueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBCursorWithValue"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBDatabaseConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBDatabase"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBFactoryConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBFactory"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBIndexConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBIndex"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBKeyRangeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBKeyRange"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBObjectStoreConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBObjectStore"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBOpenDBRequestConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBOpenDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBRequestConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBTransactionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBTransaction"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBVersionChangeEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "IDBVersionChangeEvent"), value);
}

#endif

#if ENABLE(MEDIA_SOURCE)
void setJSDOMWindowMediaSourceConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaSource"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowAudioStreamTrackConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioStreamTrack"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowWebkitMediaStreamConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitMediaStream"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowMediaStreamEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaStreamEvent"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowMediaStreamTrackConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaStreamTrack"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowMediaStreamTrackEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaStreamTrackEvent"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowRTCIceCandidateConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "RTCIceCandidate"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowWebkitRTCPeerConnectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitRTCPeerConnection"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowRTCSessionDescriptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "RTCSessionDescription"), value);
}

#endif

#if ENABLE(MEDIA_STREAM)
void setJSDOMWindowVideoStreamTrackConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "VideoStreamTrack"), value);
}

#endif

#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
void setJSDOMWindowNotificationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Notification"), value);
}

#endif

#if ENABLE(PROXIMITY_EVENTS)
void setJSDOMWindowDeviceProximityEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DeviceProximityEvent"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAnalyserNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AnalyserNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioBufferConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioBuffer"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioBufferSourceNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioBufferSourceNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitAudioContextConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitAudioContext"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioDestinationNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioDestinationNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioListenerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioListener"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioParamConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioParam"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioProcessingEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "AudioProcessingEvent"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowBiquadFilterNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "BiquadFilterNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowChannelMergerNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ChannelMergerNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowChannelSplitterNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ChannelSplitterNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowConvolverNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ConvolverNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowDelayNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DelayNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowDynamicsCompressorNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DynamicsCompressorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowGainNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "GainNode"), value);
}

#endif

#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
void setJSDOMWindowMediaElementAudioSourceNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaElementAudioSourceNode"), value);
}

#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
void setJSDOMWindowMediaStreamAudioDestinationNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaStreamAudioDestinationNode"), value);
}

#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
void setJSDOMWindowMediaStreamAudioSourceNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaStreamAudioSourceNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowOfflineAudioCompletionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "OfflineAudioCompletionEvent"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitOfflineAudioContextConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitOfflineAudioContext"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowOscillatorNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "OscillatorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitAudioPannerNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "webkitAudioPannerNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowPeriodicWaveConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PeriodicWave"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowScriptProcessorNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ScriptProcessorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWaveShaperNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WaveShaperNode"), value);
}

#endif

#if ENABLE(SQL_DATABASE)
void setJSDOMWindowSQLExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SQLException"), value);
}

#endif

void setJSDOMWindowCloseEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CloseEvent"), value);
}


#if ENABLE(WEB_SOCKETS)
void setJSDOMWindowWebSocketConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebSocket"), value);
}

#endif

void setJSDOMWindowCSSCharsetRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSCharsetRule"), value);
}


void setJSDOMWindowCSSFontFaceRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSFontFaceRule"), value);
}


#if ENABLE(SHADOW_DOM)
void setJSDOMWindowCSSHostRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSHostRule"), value);
}

#endif

void setJSDOMWindowCSSImportRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSImportRule"), value);
}


void setJSDOMWindowCSSMediaRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSMediaRule"), value);
}


void setJSDOMWindowCSSPageRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSPageRule"), value);
}


void setJSDOMWindowCSSPrimitiveValueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSPrimitiveValue"), value);
}


void setJSDOMWindowCSSRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSRule"), value);
}


void setJSDOMWindowCSSRuleListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSRuleList"), value);
}


void setJSDOMWindowCSSStyleDeclarationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSStyleDeclaration"), value);
}


void setJSDOMWindowCSSStyleRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSStyleRule"), value);
}


void setJSDOMWindowCSSStyleSheetConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSStyleSheet"), value);
}


void setJSDOMWindowCSSValueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSValue"), value);
}


void setJSDOMWindowCSSValueListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CSSValueList"), value);
}


void setJSDOMWindowCounterConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Counter"), value);
}


void setJSDOMWindowMediaListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaList"), value);
}


void setJSDOMWindowRGBColorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "RGBColor"), value);
}


void setJSDOMWindowRectConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Rect"), value);
}


void setJSDOMWindowStyleSheetConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "StyleSheet"), value);
}


void setJSDOMWindowStyleSheetListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "StyleSheetList"), value);
}


#if ENABLE(CSS_FILTERS)
void setJSDOMWindowWebKitCSSFilterValueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSFilterValue"), value);
}

#endif

void setJSDOMWindowWebKitCSSKeyframeRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSKeyframeRule"), value);
}


void setJSDOMWindowWebKitCSSKeyframesRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSKeyframesRule"), value);
}


void setJSDOMWindowWebKitCSSMatrixConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSMatrix"), value);
}


#if ENABLE(CSS_REGIONS)
void setJSDOMWindowWebKitCSSRegionRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSRegionRule"), value);
}

#endif

void setJSDOMWindowWebKitCSSTransformValueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSTransformValue"), value);
}


#if ENABLE(CSS_DEVICE_ADAPTATION)
void setJSDOMWindowWebKitCSSViewportRuleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitCSSViewportRule"), value);
}

#endif

void setJSDOMWindowAttrConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Attr"), value);
}


void setJSDOMWindowBeforeLoadEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "BeforeLoadEvent"), value);
}


void setJSDOMWindowBeforeUnloadEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "BeforeUnloadEvent"), value);
}


void setJSDOMWindowCDATASectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CDATASection"), value);
}


void setJSDOMWindowCharacterDataConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CharacterData"), value);
}


void setJSDOMWindowClientRectConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ClientRect"), value);
}


void setJSDOMWindowClientRectListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ClientRectList"), value);
}


void setJSDOMWindowClipboardConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Clipboard"), value);
}


void setJSDOMWindowCommentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Comment"), value);
}


void setJSDOMWindowCompositionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CompositionEvent"), value);
}


void setJSDOMWindowCustomEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CustomEvent"), value);
}


void setJSDOMWindowDOMExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMException"), value);
}


void setJSDOMWindowDOMImplementationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMImplementation"), value);
}


void setJSDOMWindowDOMStringListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMStringList"), value);
}


void setJSDOMWindowDOMStringMapConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMStringMap"), value);
}


#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowDeviceMotionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DeviceMotionEvent"), value);
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowDeviceOrientationEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DeviceOrientationEvent"), value);
}

#endif

void setJSDOMWindowDocumentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Document"), value);
}


void setJSDOMWindowDocumentFragmentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DocumentFragment"), value);
}


void setJSDOMWindowDocumentTypeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DocumentType"), value);
}


void setJSDOMWindowElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Element"), value);
}


void setJSDOMWindowEntityConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Entity"), value);
}


void setJSDOMWindowEntityReferenceConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "EntityReference"), value);
}


void setJSDOMWindowErrorEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ErrorEvent"), value);
}


void setJSDOMWindowEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Event"), value);
}


void setJSDOMWindowEventExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "EventException"), value);
}


void setJSDOMWindowFocusEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "FocusEvent"), value);
}


void setJSDOMWindowHashChangeEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HashChangeEvent"), value);
}


void setJSDOMWindowKeyboardEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "KeyboardEvent"), value);
}


#if ENABLE(CHANNEL_MESSAGING)
void setJSDOMWindowMessageChannelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MessageChannel"), value);
}

#endif

void setJSDOMWindowMessageEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MessageEvent"), value);
}


void setJSDOMWindowMessagePortConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MessagePort"), value);
}


void setJSDOMWindowMouseEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MouseEvent"), value);
}


void setJSDOMWindowMutationEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MutationEvent"), value);
}


void setJSDOMWindowMutationObserverConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MutationObserver"), value);
}


void setJSDOMWindowMutationRecordConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MutationRecord"), value);
}


void setJSDOMWindowNamedNodeMapConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "NamedNodeMap"), value);
}


void setJSDOMWindowNodeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Node"), value);
}


void setJSDOMWindowNodeFilterConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "NodeFilter"), value);
}


void setJSDOMWindowNodeIteratorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "NodeIterator"), value);
}


void setJSDOMWindowNodeListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "NodeList"), value);
}


void setJSDOMWindowNotationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Notation"), value);
}


void setJSDOMWindowOverflowEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "OverflowEvent"), value);
}


void setJSDOMWindowPageTransitionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PageTransitionEvent"), value);
}


void setJSDOMWindowPopStateEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PopStateEvent"), value);
}


void setJSDOMWindowProcessingInstructionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ProcessingInstruction"), value);
}


void setJSDOMWindowProgressEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ProgressEvent"), value);
}


void setJSDOMWindowRangeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Range"), value);
}


void setJSDOMWindowRangeExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "RangeException"), value);
}


#if ENABLE(CSP_NEXT)
void setJSDOMWindowSecurityPolicyViolationEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SecurityPolicyViolationEvent"), value);
}

#endif

#if ENABLE(SHADOW_DOM)
void setJSDOMWindowWebKitShadowRootConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitShadowRoot"), value);
}

#endif

void setJSDOMWindowTextConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Text"), value);
}


void setJSDOMWindowTextEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextEvent"), value);
}


#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Touch"), value);
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TouchEvent"), value);
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TouchList"), value);
}

#endif

void setJSDOMWindowTransitionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TransitionEvent"), value);
}


void setJSDOMWindowTreeWalkerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TreeWalker"), value);
}


void setJSDOMWindowUIEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "UIEvent"), value);
}


void setJSDOMWindowWebKitAnimationEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitAnimationEvent"), value);
}


void setJSDOMWindowWebKitTransitionEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitTransitionEvent"), value);
}


void setJSDOMWindowWheelEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WheelEvent"), value);
}


void setJSDOMWindowBlobConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Blob"), value);
}


void setJSDOMWindowFileConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "File"), value);
}


#if ENABLE(BLOB)
void setJSDOMWindowFileErrorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "FileError"), value);
}

#endif

void setJSDOMWindowFileListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "FileList"), value);
}


#if ENABLE(BLOB)
void setJSDOMWindowFileReaderConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "FileReader"), value);
}

#endif

void setJSDOMWindowFormDataConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "FormData"), value);
}


void setJSDOMWindowDOMSettableTokenListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMSettableTokenList"), value);
}


void setJSDOMWindowDOMTokenListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMTokenList"), value);
}


void setJSDOMWindowURLConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "URL"), value);
}


void setJSDOMWindowHTMLAllCollectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLAllCollection"), value);
}


void setJSDOMWindowHTMLAnchorElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLAnchorElement"), value);
}


void setJSDOMWindowHTMLAppletElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLAppletElement"), value);
}


void setJSDOMWindowHTMLAreaElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLAreaElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLAudioElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLAudioElement"), value);
}

#endif

#if ENABLE(VIDEO)
void setJSDOMWindowAudioConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Audio"), value);
}

#endif

void setJSDOMWindowHTMLBRElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLBRElement"), value);
}


void setJSDOMWindowHTMLBaseElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLBaseElement"), value);
}


void setJSDOMWindowHTMLBaseFontElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLBaseFontElement"), value);
}


void setJSDOMWindowHTMLBodyElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLBodyElement"), value);
}


void setJSDOMWindowHTMLButtonElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLButtonElement"), value);
}


void setJSDOMWindowHTMLCanvasElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLCanvasElement"), value);
}


void setJSDOMWindowHTMLCollectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLCollection"), value);
}


void setJSDOMWindowHTMLDListElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLDListElement"), value);
}


#if ENABLE(DATALIST_ELEMENT)
void setJSDOMWindowHTMLDataListElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLDataListElement"), value);
}

#endif

void setJSDOMWindowHTMLDirectoryElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLDirectoryElement"), value);
}


void setJSDOMWindowHTMLDivElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLDivElement"), value);
}


void setJSDOMWindowHTMLDocumentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLDocument"), value);
}


void setJSDOMWindowHTMLElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLElement"), value);
}


void setJSDOMWindowHTMLEmbedElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLEmbedElement"), value);
}


void setJSDOMWindowHTMLFieldSetElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFieldSetElement"), value);
}


void setJSDOMWindowHTMLFontElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFontElement"), value);
}


void setJSDOMWindowHTMLFormControlsCollectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFormControlsCollection"), value);
}


void setJSDOMWindowHTMLFormElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFormElement"), value);
}


void setJSDOMWindowHTMLFrameElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFrameElement"), value);
}


void setJSDOMWindowHTMLFrameSetElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLFrameSetElement"), value);
}


void setJSDOMWindowHTMLHRElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLHRElement"), value);
}


void setJSDOMWindowHTMLHeadElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLHeadElement"), value);
}


void setJSDOMWindowHTMLHeadingElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLHeadingElement"), value);
}


void setJSDOMWindowHTMLHtmlElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLHtmlElement"), value);
}


void setJSDOMWindowHTMLIFrameElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLIFrameElement"), value);
}


void setJSDOMWindowHTMLImageElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLImageElement"), value);
}


void setJSDOMWindowHTMLInputElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLInputElement"), value);
}


void setJSDOMWindowHTMLKeygenElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLKeygenElement"), value);
}


void setJSDOMWindowHTMLLIElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLLIElement"), value);
}


void setJSDOMWindowHTMLLabelElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLLabelElement"), value);
}


void setJSDOMWindowHTMLLegendElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLLegendElement"), value);
}


void setJSDOMWindowHTMLLinkElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLLinkElement"), value);
}


void setJSDOMWindowHTMLMapElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMapElement"), value);
}


void setJSDOMWindowHTMLMarqueeElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMarqueeElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLMediaElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMediaElement"), value);
}

#endif

void setJSDOMWindowHTMLMenuElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMenuElement"), value);
}


void setJSDOMWindowHTMLMetaElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMetaElement"), value);
}


#if ENABLE(METER_ELEMENT)
void setJSDOMWindowHTMLMeterElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLMeterElement"), value);
}

#endif

void setJSDOMWindowHTMLModElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLModElement"), value);
}


void setJSDOMWindowHTMLOListElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLOListElement"), value);
}


void setJSDOMWindowHTMLObjectElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLObjectElement"), value);
}


void setJSDOMWindowHTMLOptGroupElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLOptGroupElement"), value);
}


void setJSDOMWindowHTMLOptionElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLOptionElement"), value);
}


void setJSDOMWindowOptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Option"), value);
}


void setJSDOMWindowHTMLOptionsCollectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLOptionsCollection"), value);
}


void setJSDOMWindowHTMLOutputElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLOutputElement"), value);
}


void setJSDOMWindowHTMLParagraphElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLParagraphElement"), value);
}


void setJSDOMWindowHTMLParamElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLParamElement"), value);
}


void setJSDOMWindowHTMLPreElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLPreElement"), value);
}


#if ENABLE(PROGRESS_ELEMENT)
void setJSDOMWindowHTMLProgressElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLProgressElement"), value);
}

#endif

void setJSDOMWindowHTMLQuoteElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLQuoteElement"), value);
}


void setJSDOMWindowHTMLScriptElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLScriptElement"), value);
}


void setJSDOMWindowHTMLSelectElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLSelectElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLSourceElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLSourceElement"), value);
}

#endif

void setJSDOMWindowHTMLSpanElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLSpanElement"), value);
}


void setJSDOMWindowHTMLStyleElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLStyleElement"), value);
}


void setJSDOMWindowHTMLTableCaptionElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableCaptionElement"), value);
}


void setJSDOMWindowHTMLTableCellElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableCellElement"), value);
}


void setJSDOMWindowHTMLTableColElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableColElement"), value);
}


void setJSDOMWindowHTMLTableElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableElement"), value);
}


void setJSDOMWindowHTMLTableRowElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableRowElement"), value);
}


void setJSDOMWindowHTMLTableSectionElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTableSectionElement"), value);
}


#if ENABLE(TEMPLATE_ELEMENT)
void setJSDOMWindowHTMLTemplateElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTemplateElement"), value);
}

#endif

void setJSDOMWindowHTMLTextAreaElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTextAreaElement"), value);
}


void setJSDOMWindowHTMLTitleElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTitleElement"), value);
}


#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowHTMLTrackElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLTrackElement"), value);
}

#endif

void setJSDOMWindowHTMLUListElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLUListElement"), value);
}


void setJSDOMWindowHTMLUnknownElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLUnknownElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLVideoElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "HTMLVideoElement"), value);
}

#endif

void setJSDOMWindowImageDataConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "ImageData"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowMediaControllerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaController"), value);
}

#endif

#if ENABLE(VIDEO)
void setJSDOMWindowMediaErrorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaError"), value);
}

#endif

#if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
void setJSDOMWindowWebKitMediaKeyErrorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitMediaKeyError"), value);
}

#endif

#if ENABLE(ENCRYPTED_MEDIA)
void setJSDOMWindowMediaKeyEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MediaKeyEvent"), value);
}

#endif

void setJSDOMWindowTextMetricsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextMetrics"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowTimeRangesConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TimeRanges"), value);
}

#endif

void setJSDOMWindowCanvasGradientConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CanvasGradient"), value);
}


void setJSDOMWindowCanvasPatternConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CanvasPattern"), value);
}


#if ENABLE(CANVAS_PROXY)
void setJSDOMWindowCanvasProxyConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CanvasProxy"), value);
}

#endif

void setJSDOMWindowCanvasRenderingContext2DConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "CanvasRenderingContext2D"), value);
}


#if ENABLE(CANVAS_PATH)
void setJSDOMWindowPathConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Path"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLActiveInfoConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLActiveInfo"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLBufferConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLBuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLContextEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLContextEvent"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLFramebufferConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLFramebuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLProgramConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLProgram"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLRenderbufferConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLRenderbuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLRenderingContextConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLRenderingContext"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLShaderConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLShader"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLShaderPrecisionFormatConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLShaderPrecisionFormat"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLTextureConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLTexture"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLUniformLocationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebGLUniformLocation"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextTrack"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackCueConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextTrackCue"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackCueListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextTrackCueList"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TextTrackList"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTrackEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "TrackEvent"), value);
}

#endif

void setJSDOMWindowBarPropConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "BarProp"), value);
}


#if ENABLE(CSP_NEXT)
void setJSDOMWindowSecurityPolicyConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SecurityPolicy"), value);
}

#endif

void setJSDOMWindowSelectionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Selection"), value);
}


void setJSDOMWindowWindowConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Window"), value);
}


void setJSDOMWindowEventSourceConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "EventSource"), value);
}


void setJSDOMWindowHistoryConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "History"), value);
}


void setJSDOMWindowLocationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Location"), value);
}


void setJSDOMWindowNavigatorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Navigator"), value);
}


#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Performance"), value);
}

#endif

#if ENABLE(PERFORMANCE_TIMELINE)
void setJSDOMWindowPerformanceEntryConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceEntry"), value);
}

#endif

#if ENABLE(USER_TIMING)
void setJSDOMWindowPerformanceMarkConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceMark"), value);
}

#endif

#if ENABLE(USER_TIMING)
void setJSDOMWindowPerformanceMeasureConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceMeasure"), value);
}

#endif

#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceNavigationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceNavigation"), value);
}

#endif

#if ENABLE(RESOURCE_TIMING)
void setJSDOMWindowPerformanceResourceTimingConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceResourceTiming"), value);
}

#endif

#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceTimingConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PerformanceTiming"), value);
}

#endif

void setJSDOMWindowScreenConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Screen"), value);
}


#if ENABLE(INPUT_SPEECH)
void setJSDOMWindowSpeechInputEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SpeechInputEvent"), value);
}

#endif

void setJSDOMWindowWebKitPointConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "WebKitPoint"), value);
}


void setJSDOMWindowMimeTypeConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MimeType"), value);
}


void setJSDOMWindowMimeTypeArrayConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "MimeTypeArray"), value);
}


void setJSDOMWindowPluginConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Plugin"), value);
}


void setJSDOMWindowPluginArrayConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "PluginArray"), value);
}


void setJSDOMWindowStorageConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Storage"), value);
}


void setJSDOMWindowStorageEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "StorageEvent"), value);
}


#if ENABLE(SVG)
void setJSDOMWindowSVGAElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphDefElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphDefElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphItemElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphItemElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAngleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAngle"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateColorElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimateColorElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimateElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateMotionElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimateMotionElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateTransformElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimateTransformElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedAngleConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedAngle"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedBooleanConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedBoolean"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedEnumerationConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedEnumeration"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedIntegerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedInteger"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedLengthConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedLength"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedLengthListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedLengthList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedNumberConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedNumber"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedNumberListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedNumberList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedPreserveAspectRatioConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedPreserveAspectRatio"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedRectConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedRect"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedStringConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedString"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedTransformListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedTransformList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimationElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGAnimationElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGCircleElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGCircleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGClipPathElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGClipPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGColorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGColor"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGComponentTransferFunctionElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGComponentTransferFunctionElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGCursorElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGCursorElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDefsElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGDefsElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDescElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGDescElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDocumentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGDocument"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementInstanceConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGElementInstance"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementInstanceListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGElementInstanceList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGEllipseElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGEllipseElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGException"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEBlendElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEBlendElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEColorMatrixElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEColorMatrixElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEComponentTransferElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEComponentTransferElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFECompositeElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFECompositeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEConvolveMatrixElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEConvolveMatrixElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDiffuseLightingElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEDiffuseLightingElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDisplacementMapElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEDisplacementMapElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDistantLightElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEDistantLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDropShadowElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEDropShadowElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFloodElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEFloodElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncAElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncAElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncBElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncBElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncGElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncGElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncRElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncRElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEGaussianBlurElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEGaussianBlurElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEImageElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEImageElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMergeElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEMergeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMergeNodeElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEMergeNodeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMorphologyElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEMorphologyElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEOffsetElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEOffsetElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEPointLightElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFEPointLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFESpecularLightingElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFESpecularLightingElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFESpotLightElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFESpotLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFETileElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFETileElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFETurbulenceElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFETurbulenceElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFilterElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFilterElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceFormatElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceFormatElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceNameElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceNameElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceSrcElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceSrcElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceUriElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceUriElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGForeignObjectElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGForeignObjectElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGGElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGGlyphElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGGlyphElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGGlyphRefElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGGlyphRefElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGradientElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGraphicsElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGGraphicsElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGHKernElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGHKernElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGImageElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGImageElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLengthConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGLength"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLengthListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGLengthList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLineElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGLineElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLinearGradientElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGLinearGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMPathElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMarkerElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMarkerElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMaskElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMaskElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMatrixConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMatrix"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMetadataElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMetadataElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGMissingGlyphElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGMissingGlyphElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGNumberConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGNumber"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGNumberListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGNumberList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPaintConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPaint"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSeg"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegArcAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegArcAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegArcRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegArcRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegClosePathConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegClosePath"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicSmoothAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicSmoothAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicSmoothRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicSmoothRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticSmoothAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticSmoothRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoHorizontalAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoHorizontalAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoHorizontalRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoHorizontalRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoVerticalAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoVerticalAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoVerticalRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoVerticalRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegMovetoAbsConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegMovetoAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegMovetoRelConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPathSegMovetoRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPatternElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPatternElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPointConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPoint"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPointListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPointList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPolygonElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPolygonElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPolylineElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPolylineElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPreserveAspectRatioConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGPreserveAspectRatio"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRadialGradientElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGRadialGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRectConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGRect"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRectElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGRectElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRenderingIntentConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGRenderingIntent"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSVGElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGSVGElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGScriptElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGScriptElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSetElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGSetElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStopElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGStopElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStringListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGStringList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStyleElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGStyleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSwitchElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGSwitchElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSymbolElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGSymbolElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTRefElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTRefElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTSpanElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTSpanElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextContentElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTextContentElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTextElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextPathElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTextPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextPositioningElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTextPositioningElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTitleElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTitleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTransformConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTransform"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTransformListConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGTransformList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGUnitTypesConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGUnitTypes"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGUseElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGUseElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGVKernElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGVKernElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGViewElementConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGViewElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGViewSpecConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGViewSpec"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGZoomEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SVGZoomEvent"), value);
}

#endif

#if ENABLE(SHARED_WORKERS)
void setJSDOMWindowSharedWorkerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "SharedWorker"), value);
}

#endif

void setJSDOMWindowWorkerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "Worker"), value);
}


void setJSDOMWindowDOMParserConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "DOMParser"), value);
}


void setJSDOMWindowXMLHttpRequestConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequest"), value);
}


void setJSDOMWindowXMLHttpRequestExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestException"), value);
}


void setJSDOMWindowXMLHttpRequestProgressEventConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestProgressEvent"), value);
}


void setJSDOMWindowXMLHttpRequestUploadConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestUpload"), value);
}


void setJSDOMWindowXMLSerializerConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XMLSerializer"), value);
}


void setJSDOMWindowXPathEvaluatorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XPathEvaluator"), value);
}


void setJSDOMWindowXPathExceptionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XPathException"), value);
}


void setJSDOMWindowXPathExpressionConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XPathExpression"), value);
}


void setJSDOMWindowXPathResultConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XPathResult"), value);
}


#if ENABLE(XSLT)
void setJSDOMWindowXSLTProcessorConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), Identifier(exec, "XSLTProcessor"), value);
}

#endif

void setJSDOMWindowConstructor(ExecState* exec, JSObject*, EncodedJSValue thisValue, EncodedJSValue encodedValue)
{
    JSValue value = JSValue::decode(encodedValue);    JSDOMWindow* castedThis = jsDynamicCast<JSDOMWindow*>(JSValue::decode(thisValue));
    if (!castedThis) {
        if (JSDOMWindowShell* shell = jsDynamicCast<JSDOMWindowShell*>(JSValue::decode(thisValue)))
            castedThis = shell->window();
    }
    if (!castedThis) {
        throwVMTypeError(exec);
        return;
    }
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return;
    // Shadowing a built-in constructor
    castedThis->putDirect(exec->vm(), exec->propertyNames().constructor, value);
}

JSValue JSDOMWindow::getConstructor(VM& vm, JSGlobalObject* globalObject)
{
    return getDOMConstructor<JSDOMWindowConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionGetSelection(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.getSelection()));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionFocus(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    DOMWindow& impl = castedThis->impl();
    ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
    if (!scriptContext)
        return JSValue::encode(jsUndefined());
    impl.focus(scriptContext);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionBlur(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    DOMWindow& impl = castedThis->impl();
    impl.blur();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionClose(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    DOMWindow& impl = castedThis->impl();
    ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
    if (!scriptContext)
        return JSValue::encode(jsUndefined());
    impl.close(scriptContext);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionPrint(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    impl.print();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionStop(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    impl.stop();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionOpen(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->open(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionShowModalDialog(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->showModalDialog(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionAlert(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    const String& message(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.alert(message);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionConfirm(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    const String& message(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsBoolean(impl.confirm(message));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionPrompt(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    const String& message(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    const String& defaultValue(valueToStringWithUndefinedOrNullCheck(exec, exec->argument(1)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsStringOrNull(exec, impl.prompt(message, defaultValue));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionFind(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    const String& string(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool caseSensitive(exec->argument(1).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool backwards(exec->argument(2).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool wrap(exec->argument(3).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool wholeWord(exec->argument(4).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool searchInFrames(exec->argument(5).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    bool showDialog(exec->argument(6).toBoolean(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsBoolean(impl.find(string, caseSensitive, backwards, wrap, wholeWord, searchInFrames, showDialog));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionScrollBy(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    int x(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    int y(toInt32(exec, exec->argument(1), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.scrollBy(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionScrollTo(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    int x(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    int y(toInt32(exec, exec->argument(1), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.scrollTo(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionScroll(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    int x(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    int y(toInt32(exec, exec->argument(1), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.scroll(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionMoveBy(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    float x(exec->argument(0).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    float y(exec->argument(1).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.moveBy(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionMoveTo(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    float x(exec->argument(0).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    float y(exec->argument(1).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.moveTo(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionResizeBy(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    float x(exec->argument(0).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    float y(exec->argument(1).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.resizeBy(x, y);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionResizeTo(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    float width(exec->argument(0).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    float height(exec->argument(1).toFloat(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.resizeTo(width, height);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionMatchMedia(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    const String& query(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.matchMedia(query)));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionGetComputedStyle(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    Element* element(toElement(exec->argument(0)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    const String& pseudoElement(valueToStringWithUndefinedOrNullCheck(exec, exec->argument(1)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.getComputedStyle(element, pseudoElement)));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionGetMatchedCSSRules(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    Element* element(toElement(exec->argument(0)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    const String& pseudoElement(valueToStringWithUndefinedOrNullCheck(exec, exec->argument(1)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.getMatchedCSSRules(element, pseudoElement)));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitConvertPointFromPageToNode(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    Node* node(toNode(exec->argument(0)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    WebKitPoint* p(toWebKitPoint(exec->argument(1)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.webkitConvertPointFromPageToNode(node, p)));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitConvertPointFromNodeToPage(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    Node* node(toNode(exec->argument(0)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    WebKitPoint* p(toWebKitPoint(exec->argument(1)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.webkitConvertPointFromNodeToPage(node, p)));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionPostMessage(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    return JSValue::encode(castedThis->postMessage(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionRequestAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    if (!exec->argument(0).isFunction())
        return throwVMTypeError(exec);
    RefPtr<RequestAnimationFrameCallback> callback = JSRequestAnimationFrameCallback::create(asObject(exec->uncheckedArgument(0)), castedThis->globalObject());

    JSC::JSValue result = jsNumber(impl.requestAnimationFrame(callback));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionCancelAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    int id(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.cancelAnimationFrame(id);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitRequestAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    if (!exec->argument(0).isFunction())
        return throwVMTypeError(exec);
    RefPtr<RequestAnimationFrameCallback> callback = JSRequestAnimationFrameCallback::create(asObject(exec->uncheckedArgument(0)), castedThis->globalObject());

    JSC::JSValue result = jsNumber(impl.webkitRequestAnimationFrame(callback));
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitCancelAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    int id(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.cancelAnimationFrame(id);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitCancelRequestAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    int id(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.cancelAnimationFrame(id);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionAddEventListener(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->addEventListener(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionRemoveEventListener(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->removeEventListener(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionDispatchEvent(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    ExceptionCode ec = 0;
    Event* evt(toEvent(exec->argument(0)));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsBoolean(impl.dispatchEvent(evt, ec));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionCaptureEvents(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    impl.captureEvents();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionReleaseEvents(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    impl.releaseEvents();
    return JSValue::encode(jsUndefined());
}

#if ENABLE(SQL_DATABASE)
EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionOpenDatabase(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 4)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    ExceptionCode ec = 0;
    const String& name(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    const String& version(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    const String& displayName(exec->argument(2).isEmpty() ? String() : exec->argument(2).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    unsigned estimatedSize(toUInt32(exec, exec->argument(3), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    RefPtr<DatabaseCallback> creationCallback;
    if (!exec->argument(4).isUndefinedOrNull()) {
        if (!exec->uncheckedArgument(4).isFunction())
            return throwVMTypeError(exec);
        creationCallback = JSDatabaseCallback::create(asObject(exec->uncheckedArgument(4)), castedThis->globalObject());
    }

    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(DOMWindowWebDatabase::openDatabase(&impl, name, version, displayName, estimatedSize, creationCallback, ec)));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}

#endif

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionAtob(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    ExceptionCode ec = 0;
    const String& string(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsStringWithCache(exec, impl.atob(string, ec));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionBtoa(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    ExceptionCode ec = 0;
    const String& string(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());

    JSC::JSValue result = jsStringWithCache(exec, impl.btoa(string, ec));
    setDOMException(exec, ec);
    return JSValue::encode(result);
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionSetTimeout(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->setTimeout(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionClearTimeout(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    int handle(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.clearTimeout(handle);
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionSetInterval(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    return JSValue::encode(castedThis->setInterval(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionClearInterval(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThis(exec, NotStrictMode));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSDOMWindow::info());
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow& impl = castedThis->impl();
    int handle(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl.clearInterval(handle);
    return JSValue::encode(jsUndefined());
}


}
