/*
    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 "BindingSecurity.h"
#include "CSSRuleList.h"
#include "CSSStyleDeclaration.h"
#include "Console.h"
#include "Crypto.h"
#include "DOMApplicationCache.h"
#include "DOMSelection.h"
#include "DOMWindow.h"
#include "DOMWindowFileSystem.h"
#include "DOMWindowIndexedDatabase.h"
#include "DOMWindowNotifications.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 "JSArrayBuffer.h"
#include "JSArrayBufferView.h"
#include "JSAttr.h"
#include "JSBarProp.h"
#include "JSBeforeLoadEvent.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 "JSDOMWindow.h"
#include "JSDOMWindowShell.h"
#include "JSDataView.h"
#include "JSDatabaseCallback.h"
#include "JSDocument.h"
#include "JSDocumentFragment.h"
#include "JSDocumentType.h"
#include "JSElement.h"
#include "JSEntity.h"
#include "JSEntityReference.h"
#include "JSEntryCallback.h"
#include "JSErrorCallback.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 "JSFileSystemCallback.h"
#include "JSFloat32Array.h"
#include "JSFloat64Array.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 "JSInt16Array.h"
#include "JSInt32Array.h"
#include "JSInt8Array.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 "JSUint16Array.h"
#include "JSUint32Array.h"
#include "JSUint8Array.h"
#include "JSUint8ClampedArray.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 "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 "KURL.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 "StylePropertySet.h"
#include "WebKitPoint.h"
#include <runtime/Error.h>
#include <runtime/JSString.h>
#include <wtf/GetPtr.h>

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

#if ENABLE(BLOB) || ENABLE(FILE_SYSTEM)
#include "JSFileError.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"
#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(CSS_SHADERS)
#include "JSWebKitCSSFilterRule.h"
#include "JSWebKitCSSMixFunctionValue.h"
#endif

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

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

#if ENABLE(DIALOG_ELEMENT)
#include "JSHTMLDialogElement.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(METER_ELEMENT)
#include "JSHTMLMeterElement.h"
#endif

#if ENABLE(MICRODATA)
#include "JSHTMLPropertiesCollection.h"
#include "JSPropertyNodeList.h"
#endif

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

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

#if ENABLE(PROGRESS_ELEMENT)
#include "JSHTMLProgressElement.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 "JSHTMLContentElement.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(TOUCH_EVENTS)
#include "JSTouch.h"
#include "JSTouchEvent.h"
#include "JSTouchList.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 "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(WORKERS)
#include "JSWorker.h"
#endif

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

using namespace JSC;

namespace WebCore {

/* Hash table */

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

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

static const HashTableValue JSDOMWindowConstructorTableValues[] =
{
#if ENABLE(FILE_SYSTEM)
    { "TEMPORARY", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowTEMPORARY), (intptr_t)0, NoIntrinsic },
#endif
#if ENABLE(FILE_SYSTEM)
    { "PERSISTENT", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowPERSISTENT), (intptr_t)0, NoIntrinsic },
#endif
    { 0, 0, 0, 0, NoIntrinsic }
};

static const HashTable JSDOMWindowConstructorTable = { 5, 3, JSDOMWindowConstructorTableValues, 0 };

#if ENABLE(FILE_SYSTEM)
COMPILE_ASSERT(0 == DOMWindowFileSystem::TEMPORARY, DOMWindowEnumTEMPORARYIsWrongUseDoNotCheckConstants);
#endif
#if ENABLE(FILE_SYSTEM)
COMPILE_ASSERT(1 == DOMWindowFileSystem::PERSISTENT, DOMWindowEnumPERSISTENTIsWrongUseDoNotCheckConstants);
#endif

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(ExecState* exec, JSDOMGlobalObject* globalObject)
{
    Base::finishCreation(exec->vm());
    ASSERT(inherits(&s_info));
    putDirect(exec->vm(), exec->propertyNames().prototype, globalObject->prototype(), DontDelete | ReadOnly);
    putDirect(exec->vm(), exec->propertyNames().length, jsNumber(0), ReadOnly | DontDelete | DontEnum);
}

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

bool JSDOMWindowConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
    return getStaticValueDescriptor<JSDOMWindowConstructor, JSDOMWrapper>(exec, &JSDOMWindowConstructorTable, jsCast<JSDOMWindowConstructor*>(object), propertyName, descriptor);
}

/* Hash table for prototype */

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

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

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

bool JSDOMWindowPrototype::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
    JSDOMWindowPrototype* thisObject = jsCast<JSDOMWindowPrototype*>(object);
    return getStaticPropertyDescriptor<JSDOMWindowPrototype, JSObject>(exec, &JSDOMWindowPrototypeTable, thisObject, propertyName, descriptor);
}

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)
{
}

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


JSValue jsDOMWindowHistory(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->history()));
    return result;
}


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


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


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


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


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


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


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


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


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


JSValue jsDOMWindowLocation(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->location()));
    return result;
}


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


JSValue jsDOMWindowClosed(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = jsBoolean(impl->closed());
    return result;
}


JSValue jsDOMWindowLength(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = jsNumber(impl->length());
    return result;
}


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


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


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


JSValue jsDOMWindowDefaultstatus(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = jsStringWithCache(exec, impl->defaultstatus());
    return result;
}


JSValue jsDOMWindowSelf(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->self()));
    return result;
}


JSValue jsDOMWindowWindow(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->window()));
    return result;
}


JSValue jsDOMWindowFrames(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->frames()));
    return result;
}


JSValue jsDOMWindowOpener(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->opener()));
    return result;
}


JSValue jsDOMWindowParent(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->parent()));
    return result;
}


JSValue jsDOMWindowTop(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->top()));
    return result;
}


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


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


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


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


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


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


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


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


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

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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


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


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

#endif

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


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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

#if ENABLE(WEB_AUDIO)
JSValue jsDOMWindowWebkitAudioContextConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    Settings* settings = castedThis->impl()->frame() ? castedThis->impl()->frame()->settings() : 0;
    if (!settings || !settings->webAudioEnabled())
        return jsUndefined();
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSAudioContext::getConstructor(exec, castedThis);
}

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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


#if ENABLE(WEB_SOCKETS)
JSValue jsDOMWindowWebSocketConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!RuntimeEnabledFeatures::webSocketEnabled())
        return jsUndefined();
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSWebSocket::getConstructor(exec, castedThis);
}

#endif

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


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


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

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


#if ENABLE(CSS_SHADERS)
JSValue jsDOMWindowWebKitCSSFilterRuleConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSWebKitCSSFilterRule::getConstructor(exec, castedThis);
}

#endif

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

#endif

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


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


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


#if ENABLE(CSS_SHADERS)
JSValue jsDOMWindowWebKitCSSMixFunctionValueConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSWebKitCSSMixFunctionValue::getConstructor(exec, castedThis);
}

#endif

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

#endif

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


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

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

#endif

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

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


#if ENABLE(MICRODATA)
JSValue jsDOMWindowPropertyNodeListConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSPropertyNodeList::getConstructor(exec, castedThis);
}

#endif

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


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


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

#endif

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


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


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

#endif

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

#endif

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

#endif

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


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


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


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


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


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


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


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


#if ENABLE(BLOB) || ENABLE(FILE_SYSTEM)
JSValue jsDOMWindowFileErrorConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSFileError::getConstructor(exec, castedThis);
}

#endif

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


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

#endif

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


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


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


#if ENABLE(BLOB)
JSValue jsDOMWindowURLConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSDOMURL::getConstructor(exec, castedThis);
}

#endif

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


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


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


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


#if ENABLE(VIDEO)
JSValue jsDOMWindowHTMLAudioElementConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!RuntimeEnabledFeatures::htmlAudioElementEnabled())
        return jsUndefined();
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSHTMLAudioElement::getConstructor(exec, castedThis);
}

#endif

#if ENABLE(VIDEO)
JSValue jsDOMWindowAudioConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!RuntimeEnabledFeatures::audioEnabled())
        return jsUndefined();
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSHTMLAudioElement::getNamedConstructor(exec, castedThis);
}

#endif

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


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


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


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


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


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


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


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


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

#endif

#if ENABLE(DIALOG_ELEMENT)
JSValue jsDOMWindowHTMLDialogElementConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSHTMLDialogElement::getConstructor(exec, castedThis);
}

#endif

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

#endif

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


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


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

#endif

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


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


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


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


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


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


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


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


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


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


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


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

#endif

#if ENABLE(MICRODATA)
JSValue jsDOMWindowHTMLPropertiesCollectionConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSHTMLPropertiesCollection::getConstructor(exec, castedThis);
}

#endif

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


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


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


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

#endif

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


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


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


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


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


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


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


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


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


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


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

#endif

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


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


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

#endif

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


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

#endif

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

#endif

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


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

#endif

JSValue jsDOMWindowArrayBufferConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSArrayBuffer::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowArrayBufferViewConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSArrayBufferView::getConstructor(exec, castedThis);
}


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


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


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

#endif

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


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

#endif

JSValue jsDOMWindowDataViewConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSDataView::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowFloat32ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSFloat32Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowFloat64ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSFloat64Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowInt16ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSInt16Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowInt32ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSInt32Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowInt8ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSInt8Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowUint16ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSUint16Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowUint32ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSUint32Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowUint8ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSUint8Array::getConstructor(exec, castedThis);
}


JSValue jsDOMWindowUint8ClampedArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSUint8ClampedArray::getConstructor(exec, castedThis);
}


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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

#if ENABLE(SHADOW_DOM)
JSValue jsDOMWindowHTMLContentElementConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSHTMLContentElement::getConstructor(exec, castedThis);
}

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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


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

#endif

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


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


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


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


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


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


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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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


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

#endif

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


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


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


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


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


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


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


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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

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

#endif

#if ENABLE(SHARED_WORKERS)
JSValue jsDOMWindowSharedWorkerConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!RuntimeEnabledFeatures::sharedWorkerEnabled())
        return jsUndefined();
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSSharedWorker::getConstructor(exec, castedThis);
}

#endif

#if ENABLE(WORKERS)
JSValue jsDOMWindowWorkerConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    return JSWorker::getConstructor(exec, castedThis);
}

#endif

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


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


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


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


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


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


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


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


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


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


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

#endif

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

#endif

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

#endif

#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
JSValue jsDOMWindowWebkitNotifications(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return jsUndefined();
    UNUSED_PARAM(exec);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(DOMWindowNotifications::webkitNotifications(impl)));
    return result;
}

#endif

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

#endif

JSValue jsDOMWindowConstructor(ExecState* exec, JSValue slotBase, PropertyName)
{
    JSDOMWindow* domObject = jsCast<JSDOMWindow*>(asObject(slotBase));
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, domObject->impl()))
        return jsUndefined();
    return JSDOMWindow::getConstructor(exec, domObject->globalObject());
}

void setJSDOMWindowScreen(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "screen"), value);
}


void setJSDOMWindowHistory(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "history"), value);
}


void setJSDOMWindowLocationbar(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "locationbar"), value);
}


void setJSDOMWindowMenubar(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "menubar"), value);
}


void setJSDOMWindowPersonalbar(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "personalbar"), value);
}


void setJSDOMWindowScrollbars(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "scrollbars"), value);
}


void setJSDOMWindowStatusbar(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "statusbar"), value);
}


void setJSDOMWindowToolbar(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "toolbar"), value);
}


void setJSDOMWindowNavigator(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "navigator"), value);
}


void setJSDOMWindowClientInformation(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "clientInformation"), value);
}


void setJSDOMWindowLocation(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    jsCast<JSDOMWindow*>(thisObject)->setLocation(exec, value);
}


void setJSDOMWindowEvent(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "event"), value);
}


void setJSDOMWindowOffscreenBuffering(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "offscreenBuffering"), value);
}


void setJSDOMWindowOuterHeight(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "outerHeight"), value);
}


void setJSDOMWindowOuterWidth(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "outerWidth"), value);
}


void setJSDOMWindowInnerHeight(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "innerHeight"), value);
}


void setJSDOMWindowInnerWidth(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "innerWidth"), value);
}


void setJSDOMWindowScreenX(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "screenX"), value);
}


void setJSDOMWindowScreenY(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "screenY"), value);
}


void setJSDOMWindowScreenLeft(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "screenLeft"), value);
}


void setJSDOMWindowScreenTop(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "screenTop"), value);
}


void setJSDOMWindowScrollX(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "scrollX"), value);
}


void setJSDOMWindowScrollY(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "scrollY"), value);
}


void setJSDOMWindowLength(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "length"), value);
}


void setJSDOMWindowName(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(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* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(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* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(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* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(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* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "self"), value);
}


void setJSDOMWindowFrames(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "frames"), value);
}


void setJSDOMWindowOpener(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "opener"), value);
}


void setJSDOMWindowParent(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "parent"), value);
}


void setJSDOMWindowDevicePixelRatio(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "devicePixelRatio"), value);
}


void setJSDOMWindowConsole(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "console"), value);
}


void setJSDOMWindowPerformance(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "performance"), value);
}


#if ENABLE(CSS3_CONDITIONAL_RULES)
void setJSDOMWindowCSS(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in object
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSS"), value);
}

#endif

void setJSDOMWindowOnabort(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnabort(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnbeforeunload(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnbeforeunload(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnblur(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnblur(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOncanplay(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOncanplay(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOncanplaythrough(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOncanplaythrough(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnchange(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnchange(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnclick(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnclick(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOncontextmenu(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOncontextmenu(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndblclick(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndblclick(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndrag(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndrag(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndragend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndragend(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndragenter(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndragenter(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndragleave(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndragleave(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndragover(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndragover(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndragstart(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndragstart(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndrop(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndrop(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOndurationchange(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndurationchange(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnemptied(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnemptied(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnended(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnended(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnerror(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnerror(createJSErrorHandler(exec, value, thisObject));
}


void setJSDOMWindowOnfocus(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnfocus(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnhashchange(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnhashchange(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOninput(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOninput(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOninvalid(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOninvalid(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnkeydown(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnkeydown(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnkeypress(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnkeypress(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnkeyup(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnkeyup(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnload(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnload(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnloadeddata(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnloadeddata(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnloadedmetadata(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnloadedmetadata(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnloadstart(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnloadstart(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmessage(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmessage(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmousedown(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmousedown(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmouseenter(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmouseenter(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmouseleave(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmouseleave(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmousemove(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmousemove(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmouseout(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmouseout(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmouseover(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmouseover(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmouseup(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmouseup(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnmousewheel(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnmousewheel(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnoffline(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnoffline(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnonline(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnonline(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnpagehide(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnpagehide(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnpageshow(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnpageshow(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnpause(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnpause(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnplay(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnplay(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnplaying(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnplaying(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnpopstate(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnpopstate(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnprogress(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnprogress(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnratechange(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnratechange(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnresize(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnresize(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnscroll(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnscroll(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnseeked(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnseeked(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnseeking(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnseeking(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnselect(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnselect(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnstalled(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnstalled(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnstorage(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnstorage(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnsubmit(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnsubmit(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnsuspend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnsuspend(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOntimeupdate(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntimeupdate(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnunload(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnunload(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnvolumechange(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnvolumechange(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnwaiting(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwaiting(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnreset(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnreset(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnsearch(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnsearch(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnwebkitanimationend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwebkitanimationend(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnwebkitanimationiteration(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwebkitanimationiteration(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnwebkitanimationstart(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwebkitanimationstart(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOnwebkittransitionend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwebkittransitionend(createJSAttributeEventListener(exec, value, thisObject));
}


void setJSDOMWindowOntransitionend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntransitionend(createJSAttributeEventListener(exec, value, thisObject));
}


#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchstart(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntouchstart(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchmove(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntouchmove(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchend(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntouchend(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowOntouchcancel(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOntouchcancel(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowOndevicemotion(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndevicemotion(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowOndeviceorientation(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOndeviceorientation(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

#if ENABLE(PROXIMITY_EVENTS)
void setJSDOMWindowOnwebkitdeviceproximity(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    UNUSED_PARAM(exec);
    JSDOMWindow* castedThis = jsCast<JSDOMWindow*>(thisObject);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->setOnwebkitdeviceproximity(createJSAttributeEventListener(exec, value, thisObject));
}

#endif

void setJSDOMWindowImageConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Image"), value);
}


void setJSDOMWindowXMLDocumentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLDocument"), value);
}


#if ENABLE(BLOB)
void setJSDOMWindowWebkitURLConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitURL"), value);
}

#endif

void setJSDOMWindowWebKitMutationObserverConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitMutationObserver"), value);
}


#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBCursorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBCursor"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBDatabaseConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBDatabase"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBFactoryConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBFactory"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBIndexConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBIndex"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBKeyRangeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBKeyRange"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBObjectStoreConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBObjectStore"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBRequestConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowWebkitIDBTransactionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitIDBTransaction"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBCursorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBCursor"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBCursorWithValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBCursorWithValue"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBDatabaseConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBDatabase"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBFactoryConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBFactory"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBIndexConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBIndex"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBKeyRangeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBKeyRange"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBObjectStoreConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBObjectStore"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBOpenDBRequestConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBOpenDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBRequestConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBRequest"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBTransactionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBTransaction"), value);
}

#endif

#if ENABLE(INDEXED_DATABASE)
void setJSDOMWindowIDBVersionChangeEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "IDBVersionChangeEvent"), value);
}

#endif

#if ENABLE(LEGACY_NOTIFICATIONS) || ENABLE(NOTIFICATIONS)
void setJSDOMWindowNotificationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Notification"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAnalyserNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AnalyserNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioBufferConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioBuffer"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioBufferSourceNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioBufferSourceNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitAudioContextConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitAudioContext"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioDestinationNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioDestinationNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioListenerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioListener"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioParamConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioParam"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowAudioProcessingEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "AudioProcessingEvent"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowBiquadFilterNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "BiquadFilterNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowChannelMergerNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ChannelMergerNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowChannelSplitterNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ChannelSplitterNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowConvolverNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ConvolverNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowDelayNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DelayNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowDynamicsCompressorNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DynamicsCompressorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowGainNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "GainNode"), value);
}

#endif

#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
void setJSDOMWindowMediaElementAudioSourceNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MediaElementAudioSourceNode"), value);
}

#endif

#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
void setJSDOMWindowMediaStreamAudioSourceNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MediaStreamAudioSourceNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowOfflineAudioCompletionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "OfflineAudioCompletionEvent"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitOfflineAudioContextConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitOfflineAudioContext"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowOscillatorNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "OscillatorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWebkitAudioPannerNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "webkitAudioPannerNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowPeriodicWaveConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PeriodicWave"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowScriptProcessorNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ScriptProcessorNode"), value);
}

#endif

#if ENABLE(WEB_AUDIO)
void setJSDOMWindowWaveShaperNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WaveShaperNode"), value);
}

#endif

#if ENABLE(SQL_DATABASE)
void setJSDOMWindowSQLExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SQLException"), value);
}

#endif

void setJSDOMWindowCloseEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CloseEvent"), value);
}


#if ENABLE(WEB_SOCKETS)
void setJSDOMWindowWebSocketConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebSocket"), value);
}

#endif

void setJSDOMWindowCSSCharsetRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSCharsetRule"), value);
}


void setJSDOMWindowCSSFontFaceRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSFontFaceRule"), value);
}


#if ENABLE(SHADOW_DOM)
void setJSDOMWindowCSSHostRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSHostRule"), value);
}

#endif

void setJSDOMWindowCSSImportRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSImportRule"), value);
}


void setJSDOMWindowCSSMediaRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSMediaRule"), value);
}


void setJSDOMWindowCSSPageRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSPageRule"), value);
}


void setJSDOMWindowCSSPrimitiveValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSPrimitiveValue"), value);
}


void setJSDOMWindowCSSRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSRule"), value);
}


void setJSDOMWindowCSSRuleListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSRuleList"), value);
}


void setJSDOMWindowCSSStyleDeclarationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSStyleDeclaration"), value);
}


void setJSDOMWindowCSSStyleRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSStyleRule"), value);
}


void setJSDOMWindowCSSStyleSheetConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSStyleSheet"), value);
}


void setJSDOMWindowCSSValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSValue"), value);
}


void setJSDOMWindowCSSValueListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CSSValueList"), value);
}


void setJSDOMWindowCounterConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Counter"), value);
}


void setJSDOMWindowMediaListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MediaList"), value);
}


void setJSDOMWindowRGBColorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "RGBColor"), value);
}


void setJSDOMWindowRectConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Rect"), value);
}


void setJSDOMWindowStyleSheetConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "StyleSheet"), value);
}


void setJSDOMWindowStyleSheetListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "StyleSheetList"), value);
}


#if ENABLE(CSS_SHADERS)
void setJSDOMWindowWebKitCSSFilterRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSFilterRule"), value);
}

#endif

#if ENABLE(CSS_FILTERS)
void setJSDOMWindowWebKitCSSFilterValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSFilterValue"), value);
}

#endif

void setJSDOMWindowWebKitCSSKeyframeRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSKeyframeRule"), value);
}


void setJSDOMWindowWebKitCSSKeyframesRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSKeyframesRule"), value);
}


void setJSDOMWindowWebKitCSSMatrixConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSMatrix"), value);
}


#if ENABLE(CSS_SHADERS)
void setJSDOMWindowWebKitCSSMixFunctionValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSMixFunctionValue"), value);
}

#endif

#if ENABLE(CSS_REGIONS)
void setJSDOMWindowWebKitCSSRegionRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSRegionRule"), value);
}

#endif

void setJSDOMWindowWebKitCSSTransformValueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSTransformValue"), value);
}


#if ENABLE(CSS_DEVICE_ADAPTATION)
void setJSDOMWindowWebKitCSSViewportRuleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitCSSViewportRule"), value);
}

#endif

void setJSDOMWindowAttrConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Attr"), value);
}


void setJSDOMWindowBeforeLoadEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "BeforeLoadEvent"), value);
}


void setJSDOMWindowCDATASectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CDATASection"), value);
}


void setJSDOMWindowCharacterDataConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CharacterData"), value);
}


void setJSDOMWindowClientRectConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ClientRect"), value);
}


void setJSDOMWindowClientRectListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ClientRectList"), value);
}


void setJSDOMWindowClipboardConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Clipboard"), value);
}


void setJSDOMWindowCommentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Comment"), value);
}


void setJSDOMWindowCompositionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CompositionEvent"), value);
}


void setJSDOMWindowCustomEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CustomEvent"), value);
}


void setJSDOMWindowDOMExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMException"), value);
}


void setJSDOMWindowDOMImplementationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMImplementation"), value);
}


void setJSDOMWindowDOMStringListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMStringList"), value);
}


void setJSDOMWindowDOMStringMapConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMStringMap"), value);
}


#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowDeviceMotionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DeviceMotionEvent"), value);
}

#endif

#if ENABLE(DEVICE_ORIENTATION)
void setJSDOMWindowDeviceOrientationEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DeviceOrientationEvent"), value);
}

#endif

void setJSDOMWindowDocumentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Document"), value);
}


void setJSDOMWindowDocumentFragmentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DocumentFragment"), value);
}


void setJSDOMWindowDocumentTypeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DocumentType"), value);
}


void setJSDOMWindowElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Element"), value);
}


void setJSDOMWindowEntityConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Entity"), value);
}


void setJSDOMWindowEntityReferenceConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "EntityReference"), value);
}


void setJSDOMWindowErrorEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ErrorEvent"), value);
}


void setJSDOMWindowEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Event"), value);
}


void setJSDOMWindowEventExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "EventException"), value);
}


void setJSDOMWindowFocusEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "FocusEvent"), value);
}


void setJSDOMWindowHashChangeEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HashChangeEvent"), value);
}


void setJSDOMWindowKeyboardEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "KeyboardEvent"), value);
}


#if ENABLE(CHANNEL_MESSAGING)
void setJSDOMWindowMessageChannelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MessageChannel"), value);
}

#endif

void setJSDOMWindowMessageEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MessageEvent"), value);
}


void setJSDOMWindowMessagePortConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MessagePort"), value);
}


void setJSDOMWindowMouseEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MouseEvent"), value);
}


void setJSDOMWindowMutationEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MutationEvent"), value);
}


void setJSDOMWindowMutationObserverConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MutationObserver"), value);
}


void setJSDOMWindowMutationRecordConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MutationRecord"), value);
}


void setJSDOMWindowNamedNodeMapConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "NamedNodeMap"), value);
}


void setJSDOMWindowNodeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Node"), value);
}


void setJSDOMWindowNodeFilterConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "NodeFilter"), value);
}


void setJSDOMWindowNodeIteratorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "NodeIterator"), value);
}


void setJSDOMWindowNodeListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "NodeList"), value);
}


void setJSDOMWindowNotationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Notation"), value);
}


void setJSDOMWindowOverflowEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "OverflowEvent"), value);
}


void setJSDOMWindowPageTransitionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PageTransitionEvent"), value);
}


void setJSDOMWindowPopStateEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PopStateEvent"), value);
}


void setJSDOMWindowProcessingInstructionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ProcessingInstruction"), value);
}


void setJSDOMWindowProgressEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ProgressEvent"), value);
}


#if ENABLE(MICRODATA)
void setJSDOMWindowPropertyNodeListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PropertyNodeList"), value);
}

#endif

void setJSDOMWindowRangeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Range"), value);
}


void setJSDOMWindowRangeExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "RangeException"), value);
}


#if ENABLE(SHADOW_DOM)
void setJSDOMWindowWebKitShadowRootConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitShadowRoot"), value);
}

#endif

void setJSDOMWindowTextConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Text"), value);
}


void setJSDOMWindowTextEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextEvent"), value);
}


#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Touch"), value);
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TouchEvent"), value);
}

#endif

#if ENABLE(TOUCH_EVENTS)
void setJSDOMWindowTouchListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TouchList"), value);
}

#endif

void setJSDOMWindowTransitionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TransitionEvent"), value);
}


void setJSDOMWindowTreeWalkerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TreeWalker"), value);
}


void setJSDOMWindowUIEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "UIEvent"), value);
}


void setJSDOMWindowWebKitAnimationEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitAnimationEvent"), value);
}


void setJSDOMWindowWebKitTransitionEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitTransitionEvent"), value);
}


void setJSDOMWindowWheelEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WheelEvent"), value);
}


void setJSDOMWindowBlobConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Blob"), value);
}


void setJSDOMWindowFileConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "File"), value);
}


#if ENABLE(BLOB) || ENABLE(FILE_SYSTEM)
void setJSDOMWindowFileErrorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "FileError"), value);
}

#endif

void setJSDOMWindowFileListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "FileList"), value);
}


#if ENABLE(BLOB)
void setJSDOMWindowFileReaderConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "FileReader"), value);
}

#endif

void setJSDOMWindowFormDataConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "FormData"), value);
}


void setJSDOMWindowDOMSettableTokenListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMSettableTokenList"), value);
}


void setJSDOMWindowDOMTokenListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMTokenList"), value);
}


#if ENABLE(BLOB)
void setJSDOMWindowURLConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "URL"), value);
}

#endif

void setJSDOMWindowHTMLAllCollectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLAllCollection"), value);
}


void setJSDOMWindowHTMLAnchorElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLAnchorElement"), value);
}


void setJSDOMWindowHTMLAppletElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLAppletElement"), value);
}


void setJSDOMWindowHTMLAreaElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLAreaElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLAudioElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLAudioElement"), value);
}

#endif

#if ENABLE(VIDEO)
void setJSDOMWindowAudioConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Audio"), value);
}

#endif

void setJSDOMWindowHTMLBRElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLBRElement"), value);
}


void setJSDOMWindowHTMLBaseElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLBaseElement"), value);
}


void setJSDOMWindowHTMLBaseFontElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLBaseFontElement"), value);
}


void setJSDOMWindowHTMLBodyElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLBodyElement"), value);
}


void setJSDOMWindowHTMLButtonElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLButtonElement"), value);
}


void setJSDOMWindowHTMLCanvasElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLCanvasElement"), value);
}


void setJSDOMWindowHTMLCollectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLCollection"), value);
}


void setJSDOMWindowHTMLDListElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDListElement"), value);
}


#if ENABLE(DATALIST_ELEMENT)
void setJSDOMWindowHTMLDataListElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDataListElement"), value);
}

#endif

#if ENABLE(DIALOG_ELEMENT)
void setJSDOMWindowHTMLDialogElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDialogElement"), value);
}

#endif

void setJSDOMWindowHTMLDirectoryElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDirectoryElement"), value);
}


void setJSDOMWindowHTMLDivElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDivElement"), value);
}


void setJSDOMWindowHTMLDocumentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLDocument"), value);
}


void setJSDOMWindowHTMLElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLElement"), value);
}


void setJSDOMWindowHTMLEmbedElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLEmbedElement"), value);
}


void setJSDOMWindowHTMLFieldSetElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFieldSetElement"), value);
}


void setJSDOMWindowHTMLFontElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFontElement"), value);
}


void setJSDOMWindowHTMLFormControlsCollectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFormControlsCollection"), value);
}


void setJSDOMWindowHTMLFormElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFormElement"), value);
}


void setJSDOMWindowHTMLFrameElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFrameElement"), value);
}


void setJSDOMWindowHTMLFrameSetElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLFrameSetElement"), value);
}


void setJSDOMWindowHTMLHRElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLHRElement"), value);
}


void setJSDOMWindowHTMLHeadElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLHeadElement"), value);
}


void setJSDOMWindowHTMLHeadingElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLHeadingElement"), value);
}


void setJSDOMWindowHTMLHtmlElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLHtmlElement"), value);
}


void setJSDOMWindowHTMLIFrameElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLIFrameElement"), value);
}


void setJSDOMWindowHTMLImageElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLImageElement"), value);
}


void setJSDOMWindowHTMLInputElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLInputElement"), value);
}


void setJSDOMWindowHTMLKeygenElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLKeygenElement"), value);
}


void setJSDOMWindowHTMLLIElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLLIElement"), value);
}


void setJSDOMWindowHTMLLabelElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLLabelElement"), value);
}


void setJSDOMWindowHTMLLegendElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLLegendElement"), value);
}


void setJSDOMWindowHTMLLinkElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLLinkElement"), value);
}


void setJSDOMWindowHTMLMapElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMapElement"), value);
}


void setJSDOMWindowHTMLMarqueeElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMarqueeElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLMediaElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMediaElement"), value);
}

#endif

void setJSDOMWindowHTMLMenuElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMenuElement"), value);
}


void setJSDOMWindowHTMLMetaElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMetaElement"), value);
}


#if ENABLE(METER_ELEMENT)
void setJSDOMWindowHTMLMeterElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLMeterElement"), value);
}

#endif

void setJSDOMWindowHTMLModElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLModElement"), value);
}


void setJSDOMWindowHTMLOListElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLOListElement"), value);
}


void setJSDOMWindowHTMLObjectElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLObjectElement"), value);
}


void setJSDOMWindowHTMLOptGroupElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLOptGroupElement"), value);
}


void setJSDOMWindowHTMLOptionElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLOptionElement"), value);
}


void setJSDOMWindowOptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Option"), value);
}


void setJSDOMWindowHTMLOptionsCollectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLOptionsCollection"), value);
}


void setJSDOMWindowHTMLOutputElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLOutputElement"), value);
}


void setJSDOMWindowHTMLParagraphElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLParagraphElement"), value);
}


void setJSDOMWindowHTMLParamElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLParamElement"), value);
}


void setJSDOMWindowHTMLPreElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLPreElement"), value);
}


#if ENABLE(PROGRESS_ELEMENT)
void setJSDOMWindowHTMLProgressElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLProgressElement"), value);
}

#endif

#if ENABLE(MICRODATA)
void setJSDOMWindowHTMLPropertiesCollectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLPropertiesCollection"), value);
}

#endif

void setJSDOMWindowHTMLQuoteElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLQuoteElement"), value);
}


void setJSDOMWindowHTMLScriptElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLScriptElement"), value);
}


void setJSDOMWindowHTMLSelectElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLSelectElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLSourceElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLSourceElement"), value);
}

#endif

void setJSDOMWindowHTMLSpanElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLSpanElement"), value);
}


void setJSDOMWindowHTMLStyleElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLStyleElement"), value);
}


void setJSDOMWindowHTMLTableCaptionElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableCaptionElement"), value);
}


void setJSDOMWindowHTMLTableCellElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableCellElement"), value);
}


void setJSDOMWindowHTMLTableColElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableColElement"), value);
}


void setJSDOMWindowHTMLTableElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableElement"), value);
}


void setJSDOMWindowHTMLTableRowElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableRowElement"), value);
}


void setJSDOMWindowHTMLTableSectionElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTableSectionElement"), value);
}


void setJSDOMWindowHTMLTextAreaElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTextAreaElement"), value);
}


void setJSDOMWindowHTMLTitleElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTitleElement"), value);
}


#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowHTMLTrackElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLTrackElement"), value);
}

#endif

void setJSDOMWindowHTMLUListElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLUListElement"), value);
}


void setJSDOMWindowHTMLUnknownElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLUnknownElement"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowHTMLVideoElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLVideoElement"), value);
}

#endif

void setJSDOMWindowImageDataConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ImageData"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowMediaControllerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MediaController"), value);
}

#endif

#if ENABLE(VIDEO)
void setJSDOMWindowMediaErrorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MediaError"), value);
}

#endif

void setJSDOMWindowTextMetricsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextMetrics"), value);
}


#if ENABLE(VIDEO)
void setJSDOMWindowTimeRangesConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TimeRanges"), value);
}

#endif

void setJSDOMWindowArrayBufferConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ArrayBuffer"), value);
}


void setJSDOMWindowArrayBufferViewConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "ArrayBufferView"), value);
}


void setJSDOMWindowCanvasGradientConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CanvasGradient"), value);
}


void setJSDOMWindowCanvasPatternConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CanvasPattern"), value);
}


#if ENABLE(CANVAS_PROXY)
void setJSDOMWindowCanvasProxyConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CanvasProxy"), value);
}

#endif

void setJSDOMWindowCanvasRenderingContext2DConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "CanvasRenderingContext2D"), value);
}


#if ENABLE(CANVAS_PATH)
void setJSDOMWindowPathConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Path"), value);
}

#endif

void setJSDOMWindowDataViewConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DataView"), value);
}


void setJSDOMWindowFloat32ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Float32Array"), value);
}


void setJSDOMWindowFloat64ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Float64Array"), value);
}


void setJSDOMWindowInt16ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Int16Array"), value);
}


void setJSDOMWindowInt32ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Int32Array"), value);
}


void setJSDOMWindowInt8ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Int8Array"), value);
}


void setJSDOMWindowUint16ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Uint16Array"), value);
}


void setJSDOMWindowUint32ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Uint32Array"), value);
}


void setJSDOMWindowUint8ArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Uint8Array"), value);
}


void setJSDOMWindowUint8ClampedArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Uint8ClampedArray"), value);
}


#if ENABLE(WEBGL)
void setJSDOMWindowWebGLActiveInfoConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLActiveInfo"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLBufferConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLBuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLContextEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLContextEvent"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLFramebufferConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLFramebuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLProgramConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLProgram"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLRenderbufferConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLRenderbuffer"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLRenderingContextConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLRenderingContext"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLShaderConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLShader"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLShaderPrecisionFormatConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLShaderPrecisionFormat"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLTextureConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLTexture"), value);
}

#endif

#if ENABLE(WEBGL)
void setJSDOMWindowWebGLUniformLocationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebGLUniformLocation"), value);
}

#endif

#if ENABLE(SHADOW_DOM)
void setJSDOMWindowHTMLContentElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "HTMLContentElement"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextTrack"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackCueConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextTrackCue"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackCueListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextTrackCueList"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTextTrackListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TextTrackList"), value);
}

#endif

#if ENABLE(VIDEO_TRACK)
void setJSDOMWindowTrackEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "TrackEvent"), value);
}

#endif

void setJSDOMWindowBarPropConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "BarProp"), value);
}


#if ENABLE(CSP_NEXT)
void setJSDOMWindowSecurityPolicyConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SecurityPolicy"), value);
}

#endif

void setJSDOMWindowSelectionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Selection"), value);
}


void setJSDOMWindowWindowConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Window"), value);
}


void setJSDOMWindowEventSourceConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "EventSource"), value);
}


void setJSDOMWindowHistoryConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "History"), value);
}


void setJSDOMWindowLocationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Location"), value);
}


void setJSDOMWindowNavigatorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Navigator"), value);
}


#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Performance"), value);
}

#endif

#if ENABLE(PERFORMANCE_TIMELINE)
void setJSDOMWindowPerformanceEntryConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PerformanceEntry"), value);
}

#endif

#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceNavigationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PerformanceNavigation"), value);
}

#endif

#if ENABLE(RESOURCE_TIMING)
void setJSDOMWindowPerformanceResourceTimingConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PerformanceResourceTiming"), value);
}

#endif

#if ENABLE(WEB_TIMING)
void setJSDOMWindowPerformanceTimingConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PerformanceTiming"), value);
}

#endif

void setJSDOMWindowScreenConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Screen"), value);
}


#if ENABLE(INPUT_SPEECH)
void setJSDOMWindowSpeechInputEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SpeechInputEvent"), value);
}

#endif

void setJSDOMWindowWebKitPointConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "WebKitPoint"), value);
}


void setJSDOMWindowMimeTypeConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MimeType"), value);
}


void setJSDOMWindowMimeTypeArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "MimeTypeArray"), value);
}


void setJSDOMWindowPluginConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Plugin"), value);
}


void setJSDOMWindowPluginArrayConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "PluginArray"), value);
}


void setJSDOMWindowStorageConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Storage"), value);
}


void setJSDOMWindowStorageEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "StorageEvent"), value);
}


#if ENABLE(SVG)
void setJSDOMWindowSVGAElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphDefElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphDefElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGAltGlyphItemElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAltGlyphItemElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAngleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAngle"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateColorElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimateColorElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimateElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateMotionElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimateMotionElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimateTransformElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimateTransformElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedAngleConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedAngle"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedBooleanConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedBoolean"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedEnumerationConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedEnumeration"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedIntegerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedInteger"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedLengthConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedLength"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedLengthListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedLengthList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedNumberConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedNumber"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedNumberListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedNumberList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedPreserveAspectRatioConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedPreserveAspectRatio"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedRectConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedRect"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedStringConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedString"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimatedTransformListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimatedTransformList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGAnimationElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGAnimationElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGCircleElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGCircleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGClipPathElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGClipPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGColorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGColor"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGComponentTransferFunctionElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGComponentTransferFunctionElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGCursorElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGCursorElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDefsElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGDefsElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDescElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGDescElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGDocumentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGDocument"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementInstanceConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGElementInstance"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGElementInstanceListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGElementInstanceList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGEllipseElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGEllipseElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGException"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEBlendElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEBlendElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEColorMatrixElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEColorMatrixElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEComponentTransferElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEComponentTransferElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFECompositeElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFECompositeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEConvolveMatrixElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEConvolveMatrixElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDiffuseLightingElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEDiffuseLightingElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDisplacementMapElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEDisplacementMapElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDistantLightElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEDistantLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEDropShadowElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEDropShadowElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFloodElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEFloodElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncAElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncAElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncBElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncBElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncGElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncGElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEFuncRElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEFuncRElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEGaussianBlurElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEGaussianBlurElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEImageElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEImageElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMergeElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEMergeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMergeNodeElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEMergeNodeElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEMorphologyElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEMorphologyElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEOffsetElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEOffsetElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFEPointLightElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFEPointLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFESpecularLightingElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFESpecularLightingElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFESpotLightElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFESpotLightElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFETileElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFETileElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFETurbulenceElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFETurbulenceElement"), value);
}

#endif

#if ENABLE(FILTERS) && ENABLE(SVG)
void setJSDOMWindowSVGFilterElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFilterElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceFormatElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceFormatElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceNameElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceNameElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceSrcElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceSrcElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGFontFaceUriElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGFontFaceUriElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGForeignObjectElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGForeignObjectElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGGElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGGlyphElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGGlyphElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGGlyphRefElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGGlyphRefElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGradientElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGGraphicsElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGGraphicsElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGHKernElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGHKernElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGImageElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGImageElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLengthConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGLength"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLengthListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGLengthList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLineElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGLineElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGLinearGradientElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGLinearGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMPathElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMarkerElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMarkerElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMaskElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMaskElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMatrixConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMatrix"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGMetadataElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMetadataElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGMissingGlyphElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGMissingGlyphElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGNumberConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGNumber"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGNumberListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGNumberList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPaintConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPaint"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSeg"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegArcAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegArcAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegArcRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegArcRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegClosePathConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegClosePath"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicSmoothAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicSmoothAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoCubicSmoothRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoCubicSmoothRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticSmoothAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegCurvetoQuadraticSmoothRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegCurvetoQuadraticSmoothRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoHorizontalAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoHorizontalAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoHorizontalRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoHorizontalRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoVerticalAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoVerticalAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegLinetoVerticalRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegLinetoVerticalRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegMovetoAbsConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegMovetoAbs"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPathSegMovetoRelConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPathSegMovetoRel"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPatternElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPatternElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPointConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPoint"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPointListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPointList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPolygonElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPolygonElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPolylineElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPolylineElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGPreserveAspectRatioConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGPreserveAspectRatio"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRadialGradientElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGRadialGradientElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRectConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGRect"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRectElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGRectElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGRenderingIntentConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGRenderingIntent"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSVGElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGSVGElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGScriptElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGScriptElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSetElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGSetElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStopElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGStopElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStringListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGStringList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGStyleElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGStyleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSwitchElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGSwitchElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGSymbolElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGSymbolElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTRefElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTRefElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTSpanElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTSpanElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextContentElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTextContentElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTextElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextPathElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTextPathElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTextPositioningElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTextPositioningElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTitleElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTitleElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTransformConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTransform"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGTransformListConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGTransformList"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGUnitTypesConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGUnitTypes"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGUseElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGUseElement"), value);
}

#endif

#if ENABLE(SVG) && ENABLE(SVG_FONTS)
void setJSDOMWindowSVGVKernElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGVKernElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGViewElementConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGViewElement"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGViewSpecConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGViewSpec"), value);
}

#endif

#if ENABLE(SVG)
void setJSDOMWindowSVGZoomEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SVGZoomEvent"), value);
}

#endif

#if ENABLE(SHARED_WORKERS)
void setJSDOMWindowSharedWorkerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "SharedWorker"), value);
}

#endif

#if ENABLE(WORKERS)
void setJSDOMWindowWorkerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "Worker"), value);
}

#endif

void setJSDOMWindowDOMParserConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "DOMParser"), value);
}


void setJSDOMWindowXMLHttpRequestConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequest"), value);
}


void setJSDOMWindowXMLHttpRequestExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestException"), value);
}


void setJSDOMWindowXMLHttpRequestProgressEventConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestProgressEvent"), value);
}


void setJSDOMWindowXMLHttpRequestUploadConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLHttpRequestUpload"), value);
}


void setJSDOMWindowXMLSerializerConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XMLSerializer"), value);
}


void setJSDOMWindowXPathEvaluatorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XPathEvaluator"), value);
}


void setJSDOMWindowXPathExceptionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XPathException"), value);
}


void setJSDOMWindowXPathExpressionConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XPathExpression"), value);
}


void setJSDOMWindowXPathResultConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XPathResult"), value);
}


#if ENABLE(XSLT)
void setJSDOMWindowXSLTProcessorConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    UNUSED_PARAM(exec);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), Identifier(exec, "XSLTProcessor"), value);
}

#endif

void setJSDOMWindowConstructor(ExecState* exec, JSObject* thisObject, JSValue value)
{
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, jsCast<JSDOMWindow*>(thisObject)->impl()))
        return;
    // Shadowing a built-in constructor
    jsCast<JSDOMWindow*>(thisObject)->putDirect(exec->vm(), exec->propertyNames().constructor, value);
}

JSValue JSDOMWindow::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
{
    return getDOMConstructor<JSDOMWindowConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionGetSelection(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->blur();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionClose(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->print();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionStop(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->stop();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionOpen(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    return JSValue::encode(castedThis->postMessage(exec));
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionRequestAnimationFrame(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    if (exec->argumentCount() <= 0 || !exec->argument(0).isFunction())
        return throwVMTypeError(exec);
    RefPtr<RequestAnimationFrameCallback> callback = JSRequestAnimationFrameCallback::create(asObject(exec->argument(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    if (exec->argumentCount() < 1)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    if (exec->argumentCount() <= 0 || !exec->argument(0).isFunction())
        return throwVMTypeError(exec);
    RefPtr<RequestAnimationFrameCallback> callback = JSRequestAnimationFrameCallback::create(asObject(exec->argument(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->captureEvents();
    return JSValue::encode(jsUndefined());
}

EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionReleaseEvents(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    impl->releaseEvents();
    return JSValue::encode(jsUndefined());
}

#if ENABLE(FILE_SYSTEM)
EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitRequestFileSystem(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    if (exec->argumentCount() < 3)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    unsigned short type(toUInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    long long size(toInt64(exec, exec->argument(1), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    if (exec->argumentCount() <= 2 || !exec->argument(2).isFunction())
        return throwVMTypeError(exec);
    RefPtr<FileSystemCallback> successCallback = JSFileSystemCallback::create(asObject(exec->argument(2)), castedThis->globalObject());
    RefPtr<ErrorCallback> errorCallback;
    if (exec->argumentCount() > 3 && !exec->argument(3).isUndefinedOrNull()) {
        if (!exec->argument(3).isFunction())
            return throwVMTypeError(exec);
        errorCallback = JSErrorCallback::create(asObject(exec->argument(3)), castedThis->globalObject());
    }
    DOMWindowFileSystem::webkitRequestFileSystem(impl, type, size, successCallback, errorCallback);
    return JSValue::encode(jsUndefined());
}

#endif

#if ENABLE(FILE_SYSTEM)
EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionWebkitResolveLocalFileSystemURL(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    if (exec->argumentCount() < 2)
        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    const String& url(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    if (exec->argumentCount() <= 1 || !exec->argument(1).isFunction())
        return throwVMTypeError(exec);
    RefPtr<EntryCallback> successCallback = JSEntryCallback::create(asObject(exec->argument(1)), castedThis->globalObject());
    RefPtr<ErrorCallback> errorCallback;
    if (exec->argumentCount() > 2 && !exec->argument(2).isUndefinedOrNull()) {
        if (!exec->argument(2).isFunction())
            return throwVMTypeError(exec);
        errorCallback = JSErrorCallback::create(asObject(exec->argument(2)), castedThis->globalObject());
    }
    DOMWindowFileSystem::webkitResolveLocalFileSystemURL(impl, url, successCallback, errorCallback);
    return JSValue::encode(jsUndefined());
}

#endif

#if ENABLE(SQL_DATABASE)
EncodedJSValue JSC_HOST_CALL jsDOMWindowPrototypeFunctionOpenDatabase(ExecState* exec)
{
    JSDOMWindow* castedThis = toJSDOMWindow(exec->hostThisValue().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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->argumentCount() > 4 && !exec->argument(4).isUndefinedOrNull()) {
        if (!exec->argument(4).isFunction())
            return throwVMTypeError(exec);
        creationCallback = JSDatabaseCallback::create(asObject(exec->argument(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_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().toThisObject(exec));
    if (!castedThis)
        return throwVMTypeError(exec);
    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSDOMWindow::s_info);
    if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, castedThis->impl()))
        return JSValue::encode(jsUndefined());
    DOMWindow* impl = static_cast<DOMWindow*>(castedThis->impl());
    int handle(toInt32(exec, exec->argument(0), NormalConversion));
    if (exec->hadException())
        return JSValue::encode(jsUndefined());
    impl->clearInterval(handle);
    return JSValue::encode(jsUndefined());
}

// Constant getters

#if ENABLE(FILE_SYSTEM)
JSValue jsDOMWindowTEMPORARY(ExecState* exec, JSValue, PropertyName)
{
    UNUSED_PARAM(exec);
    return jsNumber(static_cast<int>(0));
}

#endif
#if ENABLE(FILE_SYSTEM)
JSValue jsDOMWindowPERSISTENT(ExecState* exec, JSValue, PropertyName)
{
    UNUSED_PARAM(exec);
    return jsNumber(static_cast<int>(1));
}

#endif

}
